{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Logistic regression with PyTorch"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "import torch.nn as nn\n",
    "from torch.optim import Optimizer\n",
    "from torch.utils.data import DataLoader\n",
    "\n",
    "# torchvision: popular datasets, model architectures, and common image transformations for computer vision.\n",
    "from torchvision import datasets\n",
    "from torchvision.transforms import transforms\n",
    "\n",
    "from random import randint\n",
    "from random import shuffle\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "\n",
    "'''\n",
    "Step 1: Prepare dataset\n",
    "'''\n",
    "# Use data with only 4 and 9 as labels: which is hardest to classify\n",
    "label_1, label_2 = 4, 9\n",
    "\n",
    "# MNIST training data\n",
    "train_set = datasets.MNIST(root='./mnist_data/', train=True, transform=transforms.ToTensor(), download=True)\n",
    "\n",
    "# Use data with two labels\n",
    "idx = (train_set.targets == label_1) + (train_set.targets == label_2)\n",
    "train_set.data = train_set.data[idx]\n",
    "train_set.targets = train_set.targets[idx]\n",
    "train_set.targets[train_set.targets == label_1] = -1\n",
    "train_set.targets[train_set.targets == label_2] = 1\n",
    "\n",
    "# MNIST testing data\n",
    "test_set = datasets.MNIST(root='./mnist_data/', train=False, transform=transforms.ToTensor())\n",
    "\n",
    "# Use data with two labels\n",
    "idx = (test_set.targets == label_1) + (test_set.targets == label_2)\n",
    "test_set.data = test_set.data[idx]\n",
    "test_set.targets = test_set.targets[idx]\n",
    "test_set.targets[test_set.targets == label_1] = -1\n",
    "test_set.targets[test_set.targets == label_2] = 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "'''\n",
    "Step 2: Define the neural network class\n",
    "'''\n",
    "class LR(nn.Module) :\n",
    "    '''\n",
    "    Initialize model\n",
    "        input_dim : dimension of given input data\n",
    "    '''\n",
    "    # MNIST data is 28x28 images\n",
    "    def __init__(self, input_dim=28*28) :\n",
    "        super().__init__()\n",
    "        self.linear = nn.Linear(input_dim, 1, bias=True)\n",
    "\n",
    "    ''' forward given input x '''\n",
    "    def forward(self, x) :\n",
    "        return self.linear(x.float().view(-1, 28*28))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "'''\n",
    "Step 3: Create the model, specify loss function and optimizer.\n",
    "'''\n",
    "model = LR()                                   # Define a Neural Network Model\n",
    "\n",
    "def logistic_loss(output, target):\n",
    "    return -torch.nn.functional.logsigmoid(target*output)\n",
    "\n",
    "loss_function = logistic_loss                                                   # Specify loss function\n",
    "optimizer = torch.optim.SGD(model.parameters(), lr=1e-4)   # specify SGD with learning rate"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Time ellapsed in training is: 0.2060258388519287\n"
     ]
    }
   ],
   "source": [
    "'''\n",
    "Step 4: Train model with SGD\n",
    "'''\n",
    "import time\n",
    "start = time.time()\n",
    "for _ in range(1000) :\n",
    "    # Sample a random data for training\n",
    "    ind = randint(0, len(train_set.data)-1)\n",
    "    image, label = train_set.data[ind], train_set.targets[ind]\n",
    "\n",
    "    # Clear previously computed gradient\n",
    "    optimizer.zero_grad()\n",
    "\n",
    "    # then compute gradient with forward and backward passes\n",
    "    train_loss = loss_function(model(image), label.float())\n",
    "    train_loss.backward()\n",
    "\n",
    "    #(This syntax will make more sense once we learn about minibatches)\n",
    "\n",
    "    # perform SGD step (parameter update)\n",
    "    optimizer.step()\n",
    "    \n",
    "end = time.time()\n",
    "print(f\"Time ellapsed in training is: {end-start}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[Test set] Average loss: 5.8580, Accuracy: 1885/1991 (94.68%)\n",
      "\n"
     ]
    }
   ],
   "source": [
    "'''\n",
    "Step 5: Test model (Evaluate the accuracy)\n",
    "'''\n",
    "test_loss, correct = 0, 0\n",
    "misclassified_ind = []\n",
    "correct_ind = []\n",
    "\n",
    "# Evaluate accuracy using test data\n",
    "for ind in range(len(test_set.data)) :\n",
    "\n",
    "    image, label = test_set.data[ind], test_set.targets[ind]\n",
    "\n",
    "    # evaluate model\n",
    "    output = model(image)\n",
    "\n",
    "    # Calculate cumulative loss\n",
    "    test_loss += loss_function(output, label.float()).item()\n",
    "\n",
    "    # Make a prediction\n",
    "    if output.item() * label.item() >= 0 :\n",
    "        correct += 1\n",
    "        correct_ind += [ind]\n",
    "    else:\n",
    "        misclassified_ind += [ind]\n",
    "\n",
    "# Print out the results\n",
    "print('[Test set] Average loss: {:.4f}, Accuracy: {}/{} ({:.2f}%)\\n'.format(\n",
    "        test_loss /len(test_set.data), correct, len(test_set.data),\n",
    "        100. * correct / len(test_set.data)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x432 with 3 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x432 with 3 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "'''\n",
    "Step 6: Show some incorrectly classified images and some correctly classified ones\n",
    "''' \n",
    "\n",
    "# Misclassified images\n",
    "shuffle(misclassified_ind)\n",
    "fig = plt.figure(1, figsize=(15, 6))\n",
    "fig.suptitle('Misclassified Figures', fontsize=16)\n",
    "\n",
    "for k in range(3) :\n",
    "    image = test_set.data[misclassified_ind[k]].cpu().numpy().astype('uint8')\n",
    "    ax = fig.add_subplot(1, 3, k+1)\n",
    "    true_label = test_set.targets[misclassified_ind[k]]\n",
    "\n",
    "    if true_label == -1 :\n",
    "        ax.set_title('True Label: {}\\nPrediction: {}'.format(label_1, label_2))\n",
    "    else :\n",
    "        ax.set_title('True Label: {}\\nPrediction: {}'.format(label_2, label_1))\n",
    "    plt.imshow(image, cmap='gray')\n",
    "plt.show()\n",
    "\n",
    "# Correctly classified images\n",
    "shuffle(correct_ind)\n",
    "fig = plt.figure(2, figsize=(15, 6))\n",
    "fig.suptitle('Correctly-classified Figures', fontsize=16)\n",
    "\n",
    "for k in range(3) :\n",
    "    image = test_set.data[correct_ind[k]].cpu().numpy().astype('uint8')\n",
    "    ax = fig.add_subplot(1, 3, k+1)\n",
    "    true_label = test_set.targets[correct_ind[k]]\n",
    "\n",
    "    if true_label == -1 :\n",
    "        ax.set_title('True Label: {}\\nPrediction: {}'.format(label_1, label_1))\n",
    "    else :\n",
    "        ax.set_title('True Label: {}\\nPrediction: {}'.format(label_2, label_2))\n",
    "    plt.imshow(image, cmap='gray')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Inspect model parameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Linear(in_features=784, out_features=1, bias=True)\n",
      "torch.Size([1, 784])\n",
      "Parameter containing:\n",
      "tensor([-0.0199], requires_grad=True)\n"
     ]
    }
   ],
   "source": [
    "# model parameters visible as an iterator (generator is an iterator)\n",
    "# print(model.parameters())\n",
    "\n",
    "# for parameter in model.parameters():\n",
    "#     print(parameter.shape)\n",
    "\n",
    "# # model parameter directly obtainable from layer\n",
    "print(model.linear)\n",
    "print(model.linear.weight.shape)\n",
    "print(model.linear.bias)  #available if bias=True\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# view the weight trained through logistic regression\n",
    "weight = model.linear.weight.detach().reshape(28,28).numpy()\n",
    "weight = weight - np.min(weight)\n",
    "weight = weight/np.max(weight)\n",
    "plt.imshow(weight, cmap='gray')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "DataLoader utility simplifies accessing data in training and testing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Time ellapsed in training is: 0.3480958938598633\n",
      "[Test set] Average loss: 0.1989, Accuracy: 1850/1991 (92.92%)\n",
      "\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x432 with 3 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAA2cAAAFoCAYAAADTgoOZAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8rg+JYAAAACXBIWXMAAAsTAAALEwEAmpwYAAAuu0lEQVR4nO3deZxcZZX/8e9XwhJIhCBgCAYhiAuLEomI4JIQBQbxhxsqioIigVEHNAoyjNiJDgr5GXFfUDYZXEAgMOAIBBJQWdMZhGBYQwhZgSRoQFQgZ/64t6VoquvervXp7s/79epXd9176j6nbnedrlP31n0cEQIAAAAAdNaLOp0AAAAAAIDmDAAAAACSQHMGAAAAAAmgOQMAAACABNCcAQAAAEACaM4AAAAAIAE0ZwBQhe032b7Q9nLb/7C92vY1to+wvUGn8yvL9g62p9keV2XdYtvntjGXc20vbtd4vcaea3tur2Vvsn2L7Sdth+09mp1jvu8L56zJ84sqX0v7yh8AMPgM63QCAJAa25+V9E1J10n6oqSHJI2StL+kH0p6XNJlHUqvv3aQ1CXp95IWdTaVjvpUlWVnSXpK0rsk/VXSvZK+Kunbbcyr0h2Sjum17O/592r5AwAGGZozAKhg+63KGrPvRcRxvVZfZvubkjZrwjgbR8TfqyzfUNIzEVF4tAXlRcSfKm/bfpGkV0k6NSKuq1j1QFsTe751EXFztRW982+Xvv5OAQCtwWmNAPB8J0laI+nEaisj4oGIuKPntu29bM+2/UR+ety1tveqvE9+qtzS/DS6G20/JWlGfsph2P6U7Rm2lys7UrJFfr/32r7Z9l9tP277Itvb987J9tG259t+yvZa29fb3sf2RElz8rBrKk6Vm1hlG3vm6w6psq4n/5qnc9re0fb5tlfa/rvtRbZrHoWyPT3P/c+2H7N9ne29e8WMsP1d20vy7a7K9/mrK2KOt72wYh/Ms/2eivX/PC3Q9pGSnlX2P/CU/HEvrnisi3uNv6nt020/mJ/i+qDt/8gbvMq48bZ/Z/tvtpfZPkWSaz3+svo4LfP1FeM9bPvkfH9GRUzP39iRve47sfffQj7G722/y/b/2v678iN2+e/2AtuP5r+D2yv3bx7zStuX2n4kz2lJ/jfLG8EAUBIFEwByefMxUdKsiPhbifjXSrpe0p8kHSkplDV319veOyL+WBG+uaRfSvqGpJOVnU7X4z8k3SZpiqQNJP3N9rHKTqE8R9JXJI2UNC3f9msjYl2ewzckfV7ZKXpdktZL2lvS9pJ+I+nTkr4v6bh8DOX5Pk9EdNu+Tdlpdf88ZdP2FpI+IGlGRDxbY1/sKOlWZacHdkm6T9JYZaeC1rKdpDMkLVV2RPJwSTfYnlDRBJ8h6f8p22/3SXqJpH31XBP7EUkz8/30O0nDJb1W0pZ9jHmlpDcrO9XzLEk/1XOnD/Z+XMMkXSVpF2WnPN6pbP+ekm//83ncVspOg10p6Yh8eyco+z2UVqWRebbaUdR8vGslLZf0MUn/kPQ5ZaexNuKVkr6j7LEukrTG9lhJt0h6JB/jUUkflHSx7XdHxOX5fa9Qdsrvv0p6TNnv9iDxRjAAlEZzBgDP2UrZC/uHSsZ/WdmL8MkR8bgk2b5G0mJlDcp7K2JHSDo8Iiobnx3yH1dJek/Pi3DbIySdLumciPhERfwtyj4XdZSkb9l+hbIXy2dExNSKsa6suE9PI7awr1PmKvxA0lm2Xx4RPfvgY5I2UtbA1DJd2b57XUQsr1h+Xq07RcQnK3LdQNJvJd2l7DEen696k6QLIuKsirteWvHzmyTdERFfqVj2mxpjPmp7bX5zacF+OUxZI/e2iLghX3atbUnqsn16RPQ0LZtJOiAiluSP5xqV/1uSsobz6V7Ljlb1fT+1Yryei4ZcpexvrxFbSdo/Im7vWWD7LGVHAN8WEavzxVflTdtXJF2eN4s7SzqkolmTpJ83mA8ADCm8mwUA9XurpCt6GjNJioi/SLpc0tt6xT6j7MhCNbN6HR15k6QXS7rA9rCeL2VHl+7Ox5Wktyur42c2+kByv1R25OPoimXHSLqyogHYoDIn512KsiNkV/RqzArZfrvtObZXK9tHTys7evOqirDbJB2Zn7Y3wS88vfI2SXvkpz6+3fam/cmhwIHKGqwbe/0urpa0obKjaFL2O7u5pzGTpIh4UtJ/92OsP0p6Q6+vWX3E7i3ppp7fSz7eU6pozOu0uLIxyx2orNn9c699cJWk19l+saTVyo60nebsNNudG8wDAIYkmjMAeM5qZacbvrxk/JaSVlRZvlLZ1R0rPVLjtMDe29gm/z5bWbNS+bW7stP6VPF9qZogP5XzHElH5S/A36LsdL4fVYQ90CufIypy6Vcetl+v7EX/E8qOlO2trCH5o6RNKkL/TdKPJX1CWSP2iO0zKpqwnyk7le6NyhqGNbYvqTgy2YhtlP099P493Jqv7/kdbKvsCGhv1Zb15YmImNfr67E+YrdVdpphI+NVU+3veRtlR1B774P/n69/Sf7mwjskzZP0dUn3OvvM4b82mA8ADCmc1ggAuYh4Jr/owjtc7ip1aySNrrJ8dL7ueZuvNXSv2z2njh2p7BS/3tbl33teuG8n6Z4a2++PHyo7Ze4QSe9RdprcVRXr3yVp44rbD1bksl0/x3qfsqNl742If57OZ3uUsiN4kqSIeELSv0v6d9svl/R+Sacp+5zVF/PG4MeSfpzfd39ln0H7lbKGrRGrlT3GD/SxfnH+fYWkl1ZZX21ZM6zQc018rfF6Pju5Ua/lL1F11f5OVyv7LN/pfdxnuSRFxCJJH8uPpr5O0mck/cD24oj4nz7uCwCoQHMGAM93mqS5yo4K9L6Ufs+FL0bmF6u4XtI7bY+suEDHSGUNzNwGcrhRWQP2ioio9Zmt2couADJF+YUpquhpMIeXGTgiHrB9tbKLWewh6SsRsb5i/Z193PVqSe+1vW1EVDv6Us2myq6aWHl1wf2UXUTjwWp3yD8LNzO/CMhuVdavlfQr22/UC+cMq8dvlTWRT0TE3TXibpJ0gu2xEfGwJNneTNnfQivcLOkLtl9WccrpcEnv7BW3StnfQO991Tuult8qO23zrvzUyZryZvl221OVHRHdTRLNGQCUQHMGABUi4ob8ReU3bb9G0rmSlig7TXGypE9K+rCyCYO/KulgZReIOF1Zk/FFZU3HV1649dI5/MX2CZK+b3trZS9s/6zsyNTbJM2NiJ/njdQZkqbmTeHlypqdvSTdHRG/UnYBkWckfcL2GmUv1O/paSb78ANlV2x8WtLZJdPuUvaC/0bbX5N0f57vgRFxeB/3+a2kz0o61/Y5yj5rdoqkZZVBtm/KH9udyk6BfJuyIzPn5evPVNbM3qTsVL9XSvqosoaxURdI+riy3/FMZadcbiRpJ2VXkHx3RPxV2RUlPyXpatvT9NzVGgubmTp9U9mpnFfZnp6PNzX//s9mNyLC9q+Unap6r7IjrO9UdlXSsr6s7DTOG2x/T9nRwlHKmq5xEfGJ/Mql31Z2tPJ+ZVcdPVLZ3951VbYJAKiC5gwAeomIb9m+VdkV+L6h7Ap265R9nuYY5Rd5iIg7nM0TdaqyRsHKjmi8rddl9OvJ4ce2H1b2Av/Dyi4+sUzSDZJur4j7gu37lTUGR0h6UlnjeHW+frXtzyhrGq9X9qJ5kmof2btS2SXxfxMRK0vmuzg/WvWfyj5zNDLP97Ia97nK9nHKmor3SVqg7LNNX+oVeoOy0wpPUvZ/a5Gkz0XEd/L1f1DWQH1U2ZQFyyX9l7KGsSER8bTtA/Kxp0jaUdk+fkDZfvpHHveY7cnKGpTzlJ0K+KM83y83mkeVvHrG+46yz9z1jLeVsn1Y6XhlnzGfln+/UNnn+Pq6QE3vsZbYnpDf/2uSts7HW6Dnrsa5UtmbGFMlvUzZ6ZR3Sjo4IrrreYwAMBS5yvQpAIAhzPY7lDV3b4+IazudD8rJr2I5X9JjETG50/kAAPqPI2cAAEmS7Z0kjVN2it58GrO02f6qslMIH1J2gY9PKpt8+6BO5gUAqB/NGQCgxymSDlf2uarep8YhPaHslMkx+c93KPsMHBffAIABitMaAQAAACABTEINAAAAAAmgOQMAAACABNCcAQAAAEACaM4AAAAAIAE0ZwAAAACQAJozAAAAAEgAzRkAAAAAJIDmDAAAAAASQHMGAAAAAAmgOQMAAACABNCcAQAAAEACaM4AAAAAIAE0ZwAAAACQAJozAAAAAEgAzRkAAAAAJIDmDAAAAAASQHMGAAAAAAmgOQMAAACABNCcAQAAAEACaM4AAAAAIAE0ZwAAAACQAJozAAAAAEgAzRkAAAAAJIDmDAAAAAASQHMGAAAAAAmgOQMAAACABNCcAQAAAEACaM4AAAAAIAE0ZwAAAACQAJozAAAAAEgAzRkAAAAAJIDmDAAAAAASQHMGAAAAAAmgOQMAAACABNCcAQAAAEACaM4AAAAAIAE0Z2gb2xNtL233fQGgCPUJQIqoTUMPzdkAZvuJiq/1tp+quP2RFo57pO3ft2r7zWB7H9u32l5n+w7bb+50TsBQQn3qG/UJ6BxqUzHbb7Mdtv+z07kMRcM6nQDqFxEjen62vVjSJyNidu8428Mi4pl25tZJtreUdLmkf5V0iaTDJP237XERsbajyQFDBPWpOuoT0FnUptpsbyjp25Ju6XQuQxVHzgahnsPYtr9oe6Wkc6q9Y5O/K/KK/OeNbX/D9hLbq2z/yPbwOsb+uO2F+TvCi2wfUyXmZNuP2V5c+S5Vs3KQtI+kVRFxUUQ8GxH/JelRSe+tY1sAmoj6RH0CUkRt+qfPS7pa0t0NbAMNoDkbvEZL2lLSyyVNKRF/uqRXStpD0iskbSfpy3WM+4ikgyW9WNLHJZ1h+/W98toq3/4Rks60/ar+5mD7B7Z/0EcOzr96L9utvw8GQEtQn164jPoEdN5Qrk2y/XJJn5D0lToeA5qE5mzwWi+pKyL+HhFP1Qq0bUlHS/pcRKyJiHWSvibpQ/0dNCKujIgHInO9sndf3tIr7JQ8r+slXSnpA/3NISI+FRGf6iONGyWNsX2Y7Q1tHyFpJ0mb9vfxAGgJ6hP1CUjRUK5NkvSdfJwn+vsY0Dx85mzwejQi/lYydmtlLwy6s+e5pOyd3A36O6jtf5HUpexdnBfl272zImRtRDxZcfshSWOamUNErLZ9iKRvSPq+pKskzZbEFYuANFCfqE9AioZsbbL9LkkjI+JX/b0vmovmbPCKXrefVMU7s7ZHV6x7TNJTknaNiGX1Dmh7Y0kXS/qYpMsi4mnbs/T8U3hG2d6soshsL2lBs3Lokb+z9IY8r2GSHpA0s9HtAmgK6hP1CUjRUK5NkyVNyD9vJ0mbS3rW9u4RcUiD20Y/cFrj0PFHSbva3sP2JpKm9ayIiPWSfqLsHOdtJMn2drYPqLE9296k8kvSRpI2Vvbh9mfyd4L2r3Lf6bY3sv0WZedYX1RnDrWSG5+fMvRiZe9QL42Iq+rZFoCWoz5Rn4AUDaXadIqe++zaHsquKvsTZZ+BQxvRnA0REXGvsg94zpZ0n6Tec218UdL9km62/Zc87lXq2z7K3q3p/XWcpAslrZX0YWVP7kor83XLJV0g6diI6LkiUOkc8qsR/ahGficqe0fpYUnbSnpPjVgAHUR9oj4BKRpKtSki1kXEyp6vPK8nI2JNjceDFnBE7yO4AAAAAIB248gZAAAAACSA5gwAAAAAEkBzBgAAAAAJoDkDAAAAgATQnKGQ7XNt/2f+81ts31Pndn5k+5TmZgdgqKI2AUgRtQmNoDkbJGwvtv2U7Sdsr7J9ju0RzR4nIn4XEbUuE9uTz5G2n3fJ2Yg4NiK+2uycqoy9se0zbC+3vdb2D2xv2OpxAbwQtel5Y1ObgERQm/rM4zrbYXtYO8fFc2jOBpd3RcQISa+X9AZJX+odMESebCdJmiBpN2UTKr5eVfYFgLahNmWoTUBaqE0VbH9E0pB5vKmiORuEImKZpP9R9gJA+Tsgn7Z9n7JJFGX7YNu3237c9o22X9tzf9vjbc+3vc72ryRtUrFuou2lFbfH2r7E9qO2V9v+nu3XSPqRpDfl70g9nsf+8zB/fvto2/fbXmP7cttjKtaF7WNt35e/w/x92y65C94l6TsRsSYiHpX0HUmf6OduBNBk1CZqE5AiapNke3NJXZJO7OfuQ5PRnA1CtsdKOkjS/1YsfrekN0raxfbrJZ0t6RhJL5H0Y0mXOzvlZiNJsySdL2lLSRdJel8f42wg6QpJD0naQdJ2kn4ZEQslHSvppogYERFbVLnvfpK+LukDkrbNt/HLXmEHK3sn63V53AH5fbfPi+P2fe2C/Kvy9svywgOgQ6hN1CYgRdQmSdLXJP1Q0soaMWgDmrPBZVb+bsvvJV2v7InW4+v5u7VPSTpa0o8j4paIeDYizpP0d0l7518bSvpWRDwdEb+WdFsf4+0laYykEyLiyYj4W0T8vo/Y3j4i6eyImB8Rf5f078reMdqhIua0iHg8IpZImiNpD0mKiCURsUW+vJr/kXS87a1tj5Z0XL5805K5AWgualOG2gSkhdokyfYESftK+m7JXNBCnFc6uLw7Imb3se7hip9fLukI2/9WsWwjZQUjJC2LiKhY91Af2xwr6aGIeKaOXMdImt9zIyKesL1a2btIi/PFle/e/FVS2Q/qnippC0m3KyueP5E0XtIjdeQJoHHUpgy1CUjLkK9Ntl8k6QeSjo+IZ/pxJiRahCNnQ0dl0XhY0qn5uyg9X5tGxC8krZC0Xa/zlPs6DP6wpO1d/cOyUWVZpeXKip0kyfZmyk4VWFb0QIpExFMR8ZmI2C4ixklaLak7Ip5tdNsAmo7aRG0CUjRUatOLlV2o6Fe2V+q5o35Lbb+lwW2jDjRnQ9NPJB1r+43ObGb7nbZHSrpJ0jOSjrM9zPZ7lR2Gr+ZWZUXptHwbm9jeN1+3StlnKTbq474/l/Rx23vY3ljZqQS3RMTiRh+c7e1sj8kf296STlH2IVcAaaM2AUjRYK5Nf1Z2VG6P/OugfPmekm5pcNuoA83ZEBQR85SdP/09SWsl3S/pyHzdPyS9N7+9VtIHJV3Sx3aeVXb1sVdIWiJpaR4vSddJukvSStuPVbnvtcpemFysrFDtJOlDZfLPP9j6RI0Ptu4k6UZJT0o6T9JJEXF1mW0D6BxqE4AUDebaFJmVPV+SHs1XrcofG9rMzz9FFgAAAADQCRw5AwAAAIAE0JwBAAAAQAJozgAAAAAgATRnAAAAAJAAmjMAAAAASEC1SfBaxjaXhgQGoYhwcVS6qE3AoPVYRGzd6SQaQX0CBqe+Xjs1dOTM9oG277F9v+2TGtkWADQT9QmApIc6nUBv1CYAtdTdnNneQNL3Jf2LpF0kHWZ7l2YlBgD1oj4BSBG1CUCRRo6c7SXp/ohYlM8g/ktJhzQnLQBoCPUJQIqoTQBqaqQ5207SwxW3l+bLnsf2FNvzbM9rYCwA6I/C+kRtAtABvHYCUFMjFwSp9iG2F3xoNSLOlHSmxIdaAbRNYX2iNgHoAF47AaipkSNnSyWNrbj9MknLG0sHAJqC+gQgRdQmADU10pzdJmln2zva3kjShyRd3py0AKAh1CcAKaI2Aaip7tMaI+IZ25+RdJWkDSSdHRF3NS0zAKgT9QlAiqhNAIo4on2nMnPeNDA4MQk1gER1R8SETifRCOoTMDi1ZBJqAAAAAEBz0JwBAAAAQAJozgAAAAAgATRnAAAAAJAAmjMAAAAASADNGQAAAAAkgOYMAAAAABJAcwYAAAAACaA5AwAAAIAE0JwBAAAAQAJozgAAAAAgATRnAAAAAJAAmjMAAAAASADNGQAAAAAkgOYMAAAAABJAcwYAAAAACaA5AwAAAIAE0JwBAAAAQAJozgAAAAAgATRnAAAAAJAAmjMAAAAASADNGQAAAAAkgOYMAAAAABJAcwYAAAAACaA5AwAAAIAE0JwBAAAAQAJozgAAAAAgATRnAAAAAJAAmjMAAAAASADNGQAAAAAkgOYMAAAAABJAcwYAAAAACaA5AwAAAIAEDOt0AgAAAADQl2nTphXGdHV1FcZMmjSpMGbu3LklMmodjpwBAAAAQAIaOnJme7GkdZKelfRMRExoRlIA0CjqE4AUUZsA1NKM0xonRcRjTdgOADQb9QlAiqhNAKritEYAAAAASECjzVlIutp2t+0p1QJsT7E9z/a8BscCgP6oWZ+oTQA6hNdOAPrU6GmN+0bEctvbSLrG9t0RcUNlQEScKelMSbIdDY4HAGXVrE/UJgAdwmsnAH1q6MhZRCzPvz8i6VJJezUjKQBoFPUJQIqoTQBqqbs5s72Z7ZE9P0vaX9KCZiUGAPWiPgFIEbUJQJFGTmt8qaRLbfds5+cR8dumZAUAjaE+AUgRtQnoZeLEiYUxZSaYHizqbs4iYpGk1zUxFwBoCuoTgBRRmwAU4VL6AAAAAJAAmjMAAAAASADNGQAAAAAkgOYMAAAAABJAcwYAAAAACaA5AwAAAIAE0JwBAAAAQAIcEe0bzG7fYIPM3nvvXRgzderUwpj3v//9zUinKT74wQ8Wxlx00UWFMRtvvHFhzIgRIwpjVq9eXRiD6iLCnc6hEdSmgeFnP/tZYcz73ve+muuHDx/erHQKdXd3F8ZcfPHFhTFXXHFFzfULFiwondMQ1B0REzqdRCOoTwPDtGnTktjGQNSsXmTu3LmFMZMmTWrKWM3Q12snjpwBAAAAQAJozgAAAAAgATRnAAAAAJAAmjMAAAAASADNGQAAAAAkgOYMAAAAABJAcwYAAAAACaA5AwAAAIAEDOt0AsjsuuuuNdfPmjWrcBtbb711YcySJUsKY2bPnt3wWAcffHDhNo466qjCmD/84Q+FMdddd11hzLp16wpj3vCGNxTGAHi+N7/5zYUxZSacL5o8WpJGjx5dGPPkk0/WXH/PPfcUbuOnP/1pYcw+++xTGLPvvvsWxpx66qmFMR/5yEdqrn/rW99auI21a9cWxgCoX1dXV2HM9OnT25BJWubMmdO2sa6//vq2jdVKHDkDAAAAgATQnAEAAABAAmjOAAAAACABNGcAAAAAkACaMwAAAABIAM0ZAAAAACSA5gwAAAAAEsA8Z23w6le/ujDmyiuvrLm+zBxm3d3dhTEHHHBAYUyZ+XC+9KUv1VxfZp6zMk4//fTCmJ133rkpYxXlfMUVVzRlHCAVw4cPL4z59Kc/XXP9KaecUriNTTfdtDDm5ptvLowpM+/hV7/61ZrrH3744cJtlKmBM2fOLIwZO3ZsYUyZOYB22WWXmutPOOGEwm2cfPLJhTEAqps2bVqnU0hW0b6ZOHFiU8aZO3duw7kMFBw5AwAAAIAE0JwBAAAAQAJozgAAAAAgATRnAAAAAJAAmjMAAAAASADNGQAAAAAkgOYMAAAAABJAcwYAAAAACWAS6gaNGzeuMObaa68tjBk9enTN9RdddFHhNoomi5XKTa769re/vTDmC1/4QmFMkT333LMwZsSIEQ2PU9aoUaPaNhbQamX+nstM6rn77rvXXB8RhdsomhhaGjyTh1YqU+N23HHHhsc5+uijC2MefPDBwphf//rXhTFl/ocAA0mZ2tPV1dX6RBJUZgLpdu2b6dOnt2WcFHDkDAAAAAASUNic2T7b9iO2F1Qs29L2Nbbvy79zyAFA21GfAKSI2gSgXmWOnJ0r6cBey06SdG1E7Czp2vw2ALTbuaI+AUjPuaI2AahDYXMWETdIWtNr8SGSzst/Pk/Su5ubFgAUoz4BSBG1CUC96r0gyEsjYoUkRcQK29v0FWh7iqQpdY4DAP1Vqj5RmwC0Ga+dABRq+dUaI+JMSWdKku3iy3oBQBtQmwCkivoEDF31Xq1xle1tJSn//kjzUgKAhlCfAKSI2gSgUL3N2eWSjsh/PkLSZc1JBwAaRn0CkCJqE4BCLppA1PYvJE2UtJWkVZK6JM2SdKGk7SUtkXRoRPT+4Gu1bQ2oQ/Obb755Ycyf/vSnwpgxY8YUxtx888011x900EGF22jW5KBTphSf5j516tSa61/5ylc2JZd169Y1ZTsjR44sjHnRi5j2r14R4U6M26z6NNBqU5m/50suuaQwZvLkyYUx11xzTc31n/vc5wq3UaZODjQveclLCmPuvffewpgyk4UXsYuffrfffnthzPjx4xvOJUHdETGh3YMO5ddOA82cOXMKY8pMxlxGmedqSop6hGaZNGlSYczcuXNbn0ib9fXaqfAzZxFxWB+riv+rA0ALUZ8ApIjaBKBeHCoAAAAAgATQnAEAAABAAmjOAAAAACABNGcAAAAAkACaMwAAAABIAM0ZAAAAACSA5gwAAAAAElA4z9lQNnz48MKY0aNHF8aUmcRvxowZNdc3a4LpMs4///zCmAMPPLDm+p133rlwG7NmzSqMOfHEEwtjrr322sKYESNGFMbsueeeNdd3d3cXbgNoh/e///2FMfvtt19hzLx58wpjiiaZHmgTTG+44YaFMe985zsLYz784Q8XxmyxxRaFMe2a5LVM/SozIXY7/xcBjWrnBNMDbZLkZj3uImX2y0Dbd63GkTMAAAAASADNGQAAAAAkgOYMAAAAABJAcwYAAAAACaA5AwAAAIAE0JwBAAAAQAJozgAAAAAgATRnAAAAAJAAJqGu4TWveU3bxho5cmTN9ZtvvnnhNspMmn344Yc3JWbXXXetuf6CCy4o3Mbxxx9fGFNmwtMyMWPHji2M2WWXXWquZxJqpGKTTTYpjFm/fn1hzC9+8YvCmJQmmR49enRhzOTJk2uuP+mkkwq3UVQLJMl2YUy7JphevHhxYUzRZOKStG7duiZkA7RP0UTK7ZpoWZImTZrUtrGKlHncZSboLqNoAumU9stAwZEzAAAAAEgAzRkAAAAAJIDmDAAAAAASQHMGAAAAAAmgOQMAAACABNCcAQAAAEACaM4AAAAAIAHMc1bDFlts0baxzjnnnJrrly9fXriNMWPGFMaUmZvnwgsvLIzp6uqquf6yyy4r3EYZo0aNakpMGePGjWvKdoBW23HHHQtjnn766cKYhx9+uBnpFDr00EMLY4466qjCmP33378wphlzi82ePbswZuXKlYUxZf6HHHzwwWVSqunEE08sjGEOMww07Zyrq0jRXF6paef8btdff33bxhoqOHIGAAAAAAmgOQMAAACABNCcAQAAAEACaM4AAAAAIAE0ZwAAAACQAJozAAAAAEgAzRkAAAAAJIDmDAAAAAASwCTUNVx66aWFMQcccEBhzAknnFAY04yJU7/73e8WxsyYMaPhcdpp++23b0pMGfvss09TtgO0WplJh3fffffCmDITzrfLsmXLCmOuueaawphf//rXNdevXbu24W1I0m677VYYc+655xbG2C6MKdo38+fPL9wGkJIykyR3dXW1PpGSyuTbjNdxA9FAm6B7IODIGQAAAAAkoLA5s3227UdsL6hYNs32Mtu3518HtTZNAHgh6hOAFFGbANSrzJGzcyUdWGX5GRGxR/71m+amBQClnCvqE4D0nCtqE4A6FDZnEXGDpDVtyAUA+oX6BCBF1CYA9WrkM2efsX1Hfuh+VF9BtqfYnmd7XgNjAUB/FNYnahOADuC1E4Ca6m3OfihpJ0l7SFohaWZfgRFxZkRMiIgJdY4FAP1Rqj5RmwC0Ga+dABSqqzmLiFUR8WxErJf0E0l7NTctAKgP9QlAiqhNAMqoqzmzvW3FzfdIWtBXLAC0E/UJQIqoTQDKKJyE2vYvJE2UtJXtpZK6JE20vYekkLRY0jGtSzFts2fPbkoMqiszYeyaNcWfuR41qs9T+/+pu7u7VE5IB/Wpb4cffnhhzJFHHtnwdso8R6+88sqmxNx9992FMe3yta99rTBm/PjxhTFlJq4tmmR60aJFhdtAew3l2lRmwuY5c+a0PhG0RTN+l7abkMngUdicRcRhVRaf1YJcAKBfqE8AUkRtAlCvRq7WCAAAAABoEpozAAAAAEgAzRkAAAAAJIDmDAAAAAASQHMGAAAAAAmgOQMAAACABNCcAQAAAEACCuc5AzqpzOTRZWLKWLhwYVO2A6Rg9erVhTEzZ85sSsxgc8YZZxTGHHzwwYUxZSaYvu222wpjykwoDqSizCTUzTJ37tya66dPn97wNqRyj6kZj7urq6vhbaSmzP7F83HkDAAAAAASQHMGAAAAAAmgOQMAAACABNCcAQAAAEACaM4AAAAAIAE0ZwAAAACQAJozAAAAAEgAzRkAAAAAJIBJqAEAQ8ahhx5aGLPffvs1Zazu7u7CmK9//euFMevWrWtGOkBblJl0uMxky5MmTWrKWM1QZpxmTGbdrEmoy+RSZv+iMzhyBgAAAAAJoDkDAAAAgATQnAEAAABAAmjOAAAAACABNGcAAAAAkACaMwAAAABIAM0ZAAAAACSA5gwAAAAAEsAk1BjwbHc6BQCJGDlyZM31p512WuE2dtxxx6bkctxxxxXG3HzzzU0ZC0hFmQmQh+r/7WZNMl1k+vTpbRkHrcGRMwAAAABIAM0ZAAAAACSA5gwAAAAAEkBzBgAAAAAJoDkDAAAAgATQnAEAAABAAmjOAAAAACABzHOGAS8imrKd8ePH11x//vnnN2UcAK1zyy231Fy/ww47FG6jTE0544wzCmNuvfXWwhgAg8O0adMKYyZOnNjwOGXmkSsTg3Rx5AwAAAAAElDYnNkea3uO7YW277J9fL58S9vX2L4v/z6q9ekCQIbaBCBV1CcA9Spz5OwZSZ+PiNdI2lvSp23vIukkSddGxM6Srs1vA0C7UJsApIr6BKAuhc1ZRKyIiPn5z+skLZS0naRDJJ2Xh50n6d0tyhEAXoDaBCBV1CcA9erXBUFs7yBpvKRbJL00IlZIWRGyvU0f95kiaUqDeQJAn6hNAFJFfQLQH6WbM9sjJF0s6bMR8Rfbpe4XEWdKOjPfRnMuqwcAOWoTgFRRnwD0V6mrNdreUFlxuSAiLskXr7K9bb5+W0mPtCZFAKiO2gQgVdQnAPUoc7VGSzpL0sKI+GbFqsslHZH/fISky5qfHgBUR20CkCrqE4B6lTmtcV9JH5V0p+3b82UnSzpN0oW2j5K0RNKhLckQaJMHH3yw0ymgf6hNQ8zMmTMLY3baaaeGx5kxY0ZTYtavX99wLhiwqE9DTFdXV1vGmTRpUlvGQecUNmcR8XtJfZ0kPbm56QBAOdQmAKmiPgGoV6nPnAEAAAAAWovmDAAAAAASQHMGAAAAAAmgOQMAAACABNCcAQAAAEACaM4AAAAAIAE0ZwAAAACQgDKTUANDwuOPP97pFIAha9y4cYUxhxxySGHMsGG1/63dddddhdu44IILCmPWrl1bGANgcJg4cWJbxpk+fXpbxkHaOHIGAAAAAAmgOQMAAACABNCcAQAAAEACaM4AAAAAIAE0ZwAAAACQAJozAAAAAEgAzRkAAAAAJIDmDAAAAAASwCTUGPBsdzoFADUMHz68MGbWrFmFMWUmqi5ywgknFMYsWLCg4XEADB5z5sxpynbmzp1bc/20adOaMg4GNo6cAQAAAEACaM4AAAAAIAE0ZwAAAACQAJozAAAAAEgAzRkAAAAAJIDmDAAAAAASQHMGAAAAAAmgOQMAAACABDAJNZK2fPnywphly5YVxowZM6YZ6QCow9SpUwtjdt5556aM9e1vf7vm+htvvLEp4wAYOoomj5akiRMnFsZMnz698WQw6HHkDAAAAAASQHMGAAAAAAmgOQMAAACABNCcAQAAAEACaM4AAAAAIAE0ZwAAAACQAJozAAAAAEgAzRkAAAAAJMAR0b7B7PYNhiHjpptuKozZa6+9CmMeeOCBmus/9KEPFW5j/vz5hTGDUUS40zk0gtpUv2222aYwpru7uzCmzETx99xzT2FM0fP0jjvuKNwGBpXuiJjQ6SQaQX0CBqe+XjsVHjmzPdb2HNsLbd9l+/h8+TTby2zfnn8d1OykAaAv1CYAqaI+AajXsBIxz0j6fETMtz1SUrfta/J1Z0TEN1qXHgD0idoEIFXUJwB1KWzOImKFpBX5z+tsL5S0XasTA4BaqE0AUkV9AlCvfl0QxPYOksZLuiVf9Bnbd9g+2/aoPu4zxfY82/MaSxUAqqM2AUgV9QlAf5RuzmyPkHSxpM9GxF8k/VDSTpL2UPbu0Mxq94uIMyNiwkD/QC6ANFGbAKSK+gSgv0o1Z7Y3VFZcLoiISyQpIlZFxLMRsV7STyQVXw4PAJqI2gQgVdQnAPUoc7VGSzpL0sKI+GbF8m0rwt4jaUHz0wOA6qhNAFJFfQJQrzJXa9xX0kcl3Wn79nzZyZIOs72HpJC0WNIxLcgPKDRjxozCmGOPPbYwZtGiRTXXD9U5zBJGbUrAJptsUhizYsWKwpgy85xNnjy5KWMBbUB9AlCXMldr/L2kapOk/ab56QBAOdQmAKmiPgGoV7+u1ggAAAAAaA2aMwAAAABIAM0ZAAAAACSA5gwAAAAAEkBzBgAAAAAJoDkDAAAAgATQnAEAAABAAhwR7RvMbt9gANomIqrN5zNgUJuAQas7IiZ0OolGUJ+Awamv104cOQMAAACABNCcAQAAAEACaM4AAAAAIAE0ZwAAAACQAJozAAAAAEgAzRkAAAAAJIDmDAAAAAASQHMGAAAAAAkY1ubxHpP0UMXtrfJlAwX5thb5tlar8n15C7bZbr1rk8Tvt9XIt7XINzMY6xO/29Yi39Yi30yftckRnZt43va8iJjQsQT6iXxbi3xba6Dl22kDbX+Rb2uRb2sNtHw7aaDtK/JtLfJtrU7ky2mNAAAAAJAAmjMAAAAASECnm7MzOzx+f5Fva5Fvaw20fDttoO0v8m0t8m2tgZZvJw20fUW+rUW+rdX2fDv6mTMAAAAAQKbTR84AAAAAAKI5AwAAAIAkdKw5s32g7Xts32/7pE7lUZbtxbbvtH277Xmdzqc322fbfsT2goplW9q+xvZ9+fdRncyxUh/5TrO9LN/Ht9s+qJM5VrI91vYc2wtt32X7+Hx5kvu4Rr7J7uNUUJuai9rUWtSmoYX61FzUp9ahNjWQSyc+c2Z7A0n3SnqHpKWSbpN0WET8qe3JlGR7saQJEZHkxHm23yrpCUk/i4jd8mUzJK2JiNPyIj4qIr7YyTx79JHvNElPRMQ3OplbNba3lbRtRMy3PVJSt6R3SzpSCe7jGvl+QInu4xRQm5qP2tRa1Kahg/rUfNSn1qE21a9TR872knR/RCyKiH9I+qWkQzqUy6AQETdIWtNr8SGSzst/Pk/ZH1kS+sg3WRGxIiLm5z+vk7RQ0nZKdB/XyBe1UZuajNrUWtSmIYX61GTUp9ahNtWvU83ZdpIerri9VOkX55B0te1u21M6nUxJL42IFVL2Rydpmw7nU8ZnbN+RH7pP4lB3b7Z3kDRe0i0aAPu4V77SANjHHURtao/knzdVJP+8oTYNetSn9kj+uVNF0s8dalP/dKo5c5VlqV/Tf9+IeL2kf5H06fzQMprrh5J2krSHpBWSZnY0mypsj5B0saTPRsRfOp1PkSr5Jr+PO4zahGqSf95Qm4YE6hOqSfq5Q23qv041Z0slja24/TJJyzuUSykRsTz//oikS5WdXpC6Vfk5tD3n0j7S4XxqiohVEfFsRKyX9BMlto9tb6jsCXtBRFySL052H1fLN/V9nABqU3sk+7ypJvXnDbVpyKA+tUeyz51qUn7uUJvq06nm7DZJO9ve0fZGkj4k6fIO5VLI9mb5hwNlezNJ+0taUPteSbhc0hH5z0dIuqyDuRTqebLm3qOE9rFtSzpL0sKI+GbFqiT3cV/5pryPE0Ftao8knzd9Sfl5Q20aUqhP7ZHkc6cvqT53qE0N5NKJqzVKkrNLUX5L0gaSzo6IUzuSSAm2xyl7x0eShkn6eWr52v6FpImStpK0SlKXpFmSLpS0vaQlkg6NiCQ+SNpHvhOVHTYOSYslHdNzXnKn2X6zpN9JulPS+nzxycrOR05uH9fI9zAluo9TQW1qLmpTa1GbhhbqU3NRn1qH2tRALp1qzgAAAAAAz+nYJNQAAAAAgOfQnAEAAABAAmjOAAAAACABNGcAAAAAkACaMwAAAABIAM0ZAAAAACSA5gwAAAAAEvB/WkH2BpkeWBAAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 1080x432 with 3 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import torch\n",
    "import torch.nn as nn\n",
    "from torch.optim import Optimizer\n",
    "from torch.utils.data import DataLoader\n",
    "from torchvision import datasets\n",
    "from torchvision.transforms import transforms\n",
    "from random import shuffle\n",
    "\n",
    "\n",
    "'''\n",
    "Step 1: (same step)\n",
    "'''\n",
    "# Use data with only 4 and 9 as labels: which is hardest to classify\n",
    "label_1, label_2 = 4, 9\n",
    "\n",
    "# MNIST training data\n",
    "train_set = datasets.MNIST(root='./mnist_data/', train=True, transform=transforms.ToTensor(), download=True)\n",
    "\n",
    "# Use data with two labels\n",
    "idx = (train_set.targets == label_1) + (train_set.targets == label_2)\n",
    "train_set.data = train_set.data[idx]\n",
    "train_set.targets = train_set.targets[idx]\n",
    "train_set.targets[train_set.targets == label_1] = -1\n",
    "train_set.targets[train_set.targets == label_2] = 1\n",
    "\n",
    "# MNIST testing data\n",
    "test_set = datasets.MNIST(root='./mnist_data/', train=False, transform=transforms.ToTensor())\n",
    "\n",
    "# Use data with two labels\n",
    "idx = (test_set.targets == label_1) + (test_set.targets == label_2)\n",
    "test_set.data = test_set.data[idx]\n",
    "test_set.targets = test_set.targets[idx]\n",
    "test_set.targets[test_set.targets == label_1] = -1\n",
    "test_set.targets[test_set.targets == label_2] = 1\n",
    "    \n",
    "\n",
    "'''\n",
    "Step 2: (same step)\n",
    "'''\n",
    "class LR(nn.Module) :\n",
    "    def __init__(self, input_dim=28*28) :\n",
    "        super().__init__()\n",
    "        self.linear = nn.Linear(input_dim, 1, bias=False)\n",
    "\n",
    "    ''' forward given input x '''\n",
    "    def forward(self, x) :\n",
    "        return self.linear(x.float().view(-1, 28*28))\n",
    "\n",
    "'''\n",
    "Step 3: (LOOK HERE)\n",
    "'''\n",
    "model = LR()                                   \n",
    "\n",
    "def logistic_loss(output, target):\n",
    "    return -torch.nn.functional.logsigmoid(target*output)\n",
    "\n",
    "loss_function = logistic_loss                               \n",
    "optimizer = torch.optim.SGD(model.parameters(), lr=255*1e-4)   # LR scaled up by 255\n",
    "\n",
    "    \n",
    "'''\n",
    "Step 4: Train model with SGD (LOOK HERE)\n",
    "'''\n",
    "# Use DataLoader class (Press Ctrl+/ to comment in/out)\n",
    "\n",
    "# 1. SGD\n",
    "# from torch.utils.data import RandomSampler\n",
    "# train_loader = DataLoader(dataset=train_set, batch_size=1, sampler=RandomSampler(train_set, replacement=True))\n",
    "\n",
    "# 2. cyclic SGD\n",
    "# train_loader = DataLoader(dataset=train_set, batch_size=1)\n",
    "\n",
    "# 3. shuffled cyclic SGD\n",
    "train_loader = DataLoader(dataset=train_set, batch_size=1, shuffle=True)\n",
    "\n",
    "# Train the model\n",
    "import time\n",
    "start = time.time()\n",
    "iter_count = 0\n",
    "\n",
    "for image,label in train_loader :\n",
    "    iter_count += 1\n",
    "    if iter_count > 1000:\n",
    "        break\n",
    "\n",
    "    # Clear previously computed gradient\n",
    "    optimizer.zero_grad()\n",
    "\n",
    "    # then compute gradient with forward and backward passes\n",
    "    train_loss = loss_function(model(image), label.float())\n",
    "    train_loss.backward()\n",
    "\n",
    "    # perform SGD step (parameter update)\n",
    "    optimizer.step()\n",
    "end = time.time()\n",
    "print(f\"Time ellapsed in training is: {end-start}\")\n",
    "\n",
    "'''\n",
    "Step 5: Test model (LOOK HERE)\n",
    "'''\n",
    "test_loss, correct = 0, 0\n",
    "misclassified_ind = []\n",
    "correct_ind = []\n",
    "\n",
    "# Test data\n",
    "test_loader = DataLoader(dataset=test_set, batch_size=1, shuffle=False)\n",
    "# no need to shuffle test data\n",
    "\n",
    "# Evaluate accuracy using test data\n",
    "for ind, (image, label) in enumerate(test_loader) :\n",
    "\n",
    "    # Forward pass\n",
    "    output = model(image)\n",
    "\n",
    "    # Calculate cumulative loss\n",
    "    test_loss += loss_function(output, label.float()).item()\n",
    "\n",
    "    # Make a prediction\n",
    "    if output.item() * label.item() >= 0 : \n",
    "        correct += 1\n",
    "        correct_ind += [ind]\n",
    "    else:\n",
    "        misclassified_ind += [ind]\n",
    "\n",
    "# Print out the results\n",
    "print('[Test set] Average loss: {:.4f}, Accuracy: {}/{} ({:.2f}%)\\n'.format(\n",
    "        test_loss /len(test_loader), correct, len(test_loader),\n",
    "        100. * correct / len(test_loader)))\n",
    "\n",
    "'''\n",
    "Step 6: (same step)\n",
    "''' \n",
    "# Misclassified images\n",
    "shuffle(misclassified_ind)\n",
    "fig = plt.figure(1, figsize=(15, 6))\n",
    "fig.suptitle('Misclassified Figures', fontsize=16)\n",
    "\n",
    "for k in range(3) :\n",
    "    image = test_set.data[misclassified_ind[k]].cpu().numpy().astype('uint8')\n",
    "    ax = fig.add_subplot(1, 3, k+1)\n",
    "    true_label = test_set.targets[misclassified_ind[k]]\n",
    "\n",
    "    if true_label == -1 :\n",
    "        ax.set_title('True Label: {}\\nPrediction: {}'.format(label_1, label_2))\n",
    "    else :\n",
    "        ax.set_title('True Label: {}\\nPrediction: {}'.format(label_2, label_1))\n",
    "    plt.imshow(image, cmap='gray')\n",
    "plt.show()\n",
    "\n",
    "# Correctly classified images\n",
    "shuffle(correct_ind)\n",
    "fig = plt.figure(2, figsize=(15, 6))\n",
    "fig.suptitle('Correctly-classified Figures', fontsize=16)\n",
    "\n",
    "for k in range(3) :\n",
    "    image = test_set.data[correct_ind[k]].cpu().numpy().astype('uint8')\n",
    "    ax = fig.add_subplot(1, 3, k+1)\n",
    "    true_label = test_set.targets[correct_ind[k]]\n",
    "\n",
    "    if true_label == -1 :\n",
    "        ax.set_title('True Label: {}\\nPrediction: {}'.format(label_1, label_1))\n",
    "    else :\n",
    "        ax.set_title('True Label: {}\\nPrediction: {}'.format(label_2, label_2))\n",
    "    plt.imshow(image, cmap='gray')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "DataLoader scales the image by a factor of 255 and converts the data type to a float."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([[  0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,\n",
      "           0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0],\n",
      "        [  0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,\n",
      "           0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0],\n",
      "        [  0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,\n",
      "           0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0],\n",
      "        [  0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,\n",
      "           0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0],\n",
      "        [  0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,\n",
      "           0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0],\n",
      "        [  0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   3,  18,\n",
      "          18,  18, 126, 136, 175,  26, 166, 255, 247, 127,   0,   0,   0,   0],\n",
      "        [  0,   0,   0,   0,   0,   0,   0,   0,  30,  36,  94, 154, 170, 253,\n",
      "         253, 253, 253, 253, 225, 172, 253, 242, 195,  64,   0,   0,   0,   0],\n",
      "        [  0,   0,   0,   0,   0,   0,   0,  49, 238, 253, 253, 253, 253, 253,\n",
      "         253, 253, 253, 251,  93,  82,  82,  56,  39,   0,   0,   0,   0,   0],\n",
      "        [  0,   0,   0,   0,   0,   0,   0,  18, 219, 253, 253, 253, 253, 253,\n",
      "         198, 182, 247, 241,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0],\n",
      "        [  0,   0,   0,   0,   0,   0,   0,   0,  80, 156, 107, 253, 253, 205,\n",
      "          11,   0,  43, 154,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0],\n",
      "        [  0,   0,   0,   0,   0,   0,   0,   0,   0,  14,   1, 154, 253,  90,\n",
      "           0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0],\n",
      "        [  0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 139, 253, 190,\n",
      "           2,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0],\n",
      "        [  0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,  11, 190, 253,\n",
      "          70,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0],\n",
      "        [  0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,  35, 241,\n",
      "         225, 160, 108,   1,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0],\n",
      "        [  0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,  81,\n",
      "         240, 253, 253, 119,  25,   0,   0,   0,   0,   0,   0,   0,   0,   0],\n",
      "        [  0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,\n",
      "          45, 186, 253, 253, 150,  27,   0,   0,   0,   0,   0,   0,   0,   0],\n",
      "        [  0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,\n",
      "           0,  16,  93, 252, 253, 187,   0,   0,   0,   0,   0,   0,   0,   0],\n",
      "        [  0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,\n",
      "           0,   0,   0, 249, 253, 249,  64,   0,   0,   0,   0,   0,   0,   0],\n",
      "        [  0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,\n",
      "          46, 130, 183, 253, 253, 207,   2,   0,   0,   0,   0,   0,   0,   0],\n",
      "        [  0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,  39, 148,\n",
      "         229, 253, 253, 253, 250, 182,   0,   0,   0,   0,   0,   0,   0,   0],\n",
      "        [  0,   0,   0,   0,   0,   0,   0,   0,   0,   0,  24, 114, 221, 253,\n",
      "         253, 253, 253, 201,  78,   0,   0,   0,   0,   0,   0,   0,   0,   0],\n",
      "        [  0,   0,   0,   0,   0,   0,   0,   0,  23,  66, 213, 253, 253, 253,\n",
      "         253, 198,  81,   2,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0],\n",
      "        [  0,   0,   0,   0,   0,   0,  18, 171, 219, 253, 253, 253, 253, 195,\n",
      "          80,   9,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0],\n",
      "        [  0,   0,   0,   0,  55, 172, 226, 253, 253, 253, 253, 244, 133,  11,\n",
      "           0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0],\n",
      "        [  0,   0,   0,   0, 136, 253, 253, 253, 212, 135, 132,  16,   0,   0,\n",
      "           0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0],\n",
      "        [  0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,\n",
      "           0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0],\n",
      "        [  0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,\n",
      "           0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0],\n",
      "        [  0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,\n",
      "           0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0]],\n",
      "       dtype=torch.uint8)\n"
     ]
    }
   ],
   "source": [
    "train_set = datasets.MNIST(root='./mnist_data/', train=True, transform=transforms.ToTensor(), download=True)\n",
    "print(train_set.data[0])\n",
    "# train_loader = DataLoader(dataset=train_set, batch_size=1, shuffle=True)\n",
    "# print(next(iter(train_loader)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The data loader creates a iterator that end when all data has been processed"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Time ellapsed in training is: 4.084276914596558\n",
      "[Test set] Average loss: 0.1153, Accuracy: 1907/1991 (95.78%)\n",
      "\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAA2cAAAFoCAYAAADTgoOZAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8rg+JYAAAACXBIWXMAAAsTAAALEwEAmpwYAAArhklEQVR4nO3deZxcdZnv8e+XhDUsggEMSxJluyJIcJAdxDsKgngRRsAISFDZBiSIM4IgAoISle3eQcGwCDIgewRZRhCRbRQJESGaAAEDBJJAEsI2YUue+8c5LUXTVb/qru3X3Z/369Wv7jrnqd95ujr1pJ46vzo/R4QAAAAAAJ21VKcTAAAAAADQnAEAAABAFmjOAAAAACADNGcAAAAAkAGaMwAAAADIAM0ZAAAAAGSA5gwAOsD2ONtRfm3Yw/6dKvZ/qmL7JbZnNjmX0eVxxjVz3DqP3fV77lSxbSnb59iebXuJ7V+1IsdyvJPrzK+nr6/1lD8AAH01tNMJAMAg94qkAySd2G37l8t9K3Xbfqqk/9uGvNpliqRtJP2tYtsXJI2X9E1Jf5A0X9LsMu6JdidYOkrSA922PSHpDb03fwAA+oTmDAA663pJ+9v+bkSEJNleXtK/SLpO0rjK4IjoVHPSEhHxsqQ/dtv84fL7ORGxpGJ797h2mhYR1Y7f9rxsLxsRb7T7uACA1mJaIwB01mWSRknavmLbnpKGqGjO3qX7tEbbQ22favsJ26/bnmf7Xtvbd7vfwban2F5k+0Xbd9netlpStj9u+1rbs8r7PGr7B2XjWBm3i+37bL9k+9Uy7rsV+ze0Pcn282V+T9u+xvbQcv+7pgWWv9vJ5d0Xd01lrDat0fYnbN9h+xXbr9n+je1NusUMsX1aOU3yf2z/3vZHqv3uvVFlWmb34/3O9v/qPo2y2hTVMr/f93CMvWxfYPsFSXMr9h9s+y8Vf/+LbK/WbczxtqdV/P0n296zGY8BAKB5OHMGAJ31lKS7VUxtvKfc9mVJkyS9Wsf9j5X0DUknSHpI0sqStpD0jxfnts9QMUXwIkknSVoiaWtJIyX9d5VxR5bjXaJieuVHJH1X0ockfbEc90OSbpR0rYrplm9K2qCM6XKTpIWSDpc0T9LaknZT9TcH91QxhXCciumCUjF9cFj3QNuflXSDpJsl7V/xeNxj+6MR8Uy57WRJx0s6S9JtKh6fG6scv5qluhrKUkTE4iqxp5TH+7Gk30r6WB+O15P/kHSrin8ry0mS7Qkq/rb/T9K/q3h8T5O0ie1tI2Kx7f0knSnpeyr+jS0v6aOq+DcCAMgDzRkAdN4vJJ1p+yhJq0r6lKRd67zvNpJui4jKz6H9uusH2+uraN7OjohjKmJurjVoRPzjrJ1tS7pP0suSfmH7iIiYr6LpWEbS4eX0REn6XcX9hqto1vaIiMrm5Ioax/2z7WfLn/8xXdD2e5ozFZ+9uysi9qiIu1PSkyoalqNtr1r+/hMj4t/KsNtsL5Y0odZj0M1vut1+VtI63YPK4x0t6fyIOLbcfLvtt1Q0SI34U0R8reJYo1U0ZKdExPcqtj8m6V5Jn5P0KxX/Rh6ujJF0S4O5AABagGmNANB510haVsWL6f0kzZF0R533fUDSbra/b3t728t02/8pFbV+Ym8Ssr2y7R/a7rroxVsqpmBaRcMlFWfW3pJ0pe0v2F6j2zDzVTRKE8qpdxuoScqx1pN0eTm1c2h5Zut/VFxEZMcydFMVZ92u7jbElb085BGSPl7xtVuVuK7jXdNt+7W9PF5PJnW7/WkVf9vuj8H9KhrprsfgAUljbP+H7U/ZXqEJuQAAWoDmDAA6LCJeUXGG4wAVUxov73YhjFp+oGKq4v9RMWVtvu2fl2etJOn95fdZvUzr55IOUzFd7tMqGpIjyn3LlXnPkLSLiv9LLpM0x/b9tj9R7o/yvpMlnS7pMdtP2j68l7n0pKsRvEhFg1j5tbve+b1HlN/n6t263055LCImV3w9XCWu63jPN3i8nszudrvrMZih9z4GK+udx+AXKqaVbqXiDOAC29eXZ94AABlhWiMA5OEXKqYaLiVpbL13ioi3JP1Q0g9tf0BFY3KWpBUk7avic15S8VmkR+sZ0/ZykvaQdHLldEnbm/Zw/Dsl3Wl7WUnbqfhc0822R0fEvIh4UtKXy6mRm0k6UtJPbc+MiFvr/T17ML/8/m0Vn+vq7s3ye1dDs6akv1bsX7OBY9fSdbw16jje6yqmhXb3fr3z+1WKbre7YnaW9GIP8fOlfzTJP5P0s3La5c4qplhepaJhAwBkguYMAPJwu4qpdwsj4q+p4J5ExBxJF9reTVLXFQt/q+ICIIeo+BxWPZZVcbXIt7ptH1fj2G9I+p3tFVVcpOODeqcx7GoQHrJ9jKSvlvk10pw9KmmmpI9ERK3Pjj0s6TVJ+6ji83AqL2rSAo+Ux9tb0p0V2/fuIfYpSWvaHh4R8yTJ9nqSNlL1C7VUul3F33ZkRNxeT3IR8aKkq2xvJenQeu4DAGgfmjMAyEB55b+6z5h1sX2DpL+oWMz5RUmbS/qMijMliognbJ8t6RjbK6m4auBiSVtKmh4RV/WQy0u2/yjpm7Znq2iyvqLi7FvlsQ9T8bmmWyQ9I2m4ijNZz0maavujKi7acZWKqXdDVDR4b+vdjVKvRUTYPkLSDeXn7K4u81xT0raSno6IsyJiYfn7n2D7FRVXa/y4igax6SLiRdvnSDq+PF7X1Rq7jlc5XfUaFVe5vNz2WXrn8ZunOpR/2x9KOtf2RpLuUnE2bl0V00kvjIg7bU9UccXNP6iYbrmhiim0tzXyuwIAmo/mDAD6t7tVnJU5QsVUxqcl/UjS97sCIuLfbM+Q9K+SDlRxZudh1X5xPlbSeZJ+ImmRiuZnvIpL43f5i4qrSp6uYhrfAhVXCdwvIhbZnlPmc4yKKxu+ruLM0u4R8WBDv3Xxe91ie0cVywhcqOIS8XNULApd2XSerOJCJl9TMa3yfhUXX+nTGco6nFQe76sqlgW4X0VTep+klyryn2H7Cyouff8rSY+peKyOr/dAEXG87Wkq/v5HqJj6+IyKC8o8XobdJ+kgFQ3ZKiqa5/8s8wQAZMTFTBMAANAqtvdW0eDuGBH3pOIBAIMTzRkAAE1Ufp7rsyrOmL0u6Z8kHafic3LbBv/xAgCqYFojAADN9aqKz+IdoeKS9s+rOGv2bRozAEAtnDkDAAAAgAywCDUAAAAAZIDmDAAAAAAyQHMGAAAAABmgOQMAAACADNCcAQAAAEAGaM4AAAAAIAM0ZwAAAACQAZozAAAAAMgAzRkAAAAAZIDmDAAAAAAyQHMGAAAAABmgOQMAAACADNCcAQAAAEAGaM4AAAAAIAM0ZwAAAACQAZozAAAAAMgAzRkAAAAAZIDmDAAAAAAyQHMGAAAAABmgOQMAAACADNCcAQAAAEAGaM4AAAAAIAM0ZwAAAACQAZozAAAAAMgAzRkAAAAAZIDmDAAAAAAyQHMGAAAAABmgOQMAAACADNCcAQAAAEAGaM4AAAAAIAM0ZwAAAACQAZozAAAAAMgAzRkAAAAAZIDmDAAAAAAyQHMGAAAAABmgOQMAAACADNCcoW1s72R7VrvvCwAp1CcAOaI2DT40Z/2Y7VcrvpbYXlRxe78WHnec7XtbNX4z2N7W9p9sv2L7YdvbdzonYDChPlVHfQI6h9pUHbUpDzRn/VhErNj1JelpSZ+r2HZ5V5ztoZ3Lsv1srybpRkk/lvQ+ST+S9Gvbq3YyL2AwoT71jPoEdBa1qWfUpnzQnA1AXaexbR9re46kn/f0jo3tsL1++fOyts+w/bTtubbPt718H459kO1p5bsuT9o+tIeY423Psz2z8l2qZuUgaVtJcyPimohYHBH/KekFSXv1YSwATUR9oj4BOaI2UZtyQXM2cH1A0mqSRkk6pI74H0raUNIYSetLWlvSd/tw3Ocl7S5pZUkHSTrb9se65TW8HP9ASRNtb9TbHGz/1PZPq+Tg8qv7tk16+8sAaAnq03u3UZ+AzqM2vXcbtanNaM4GriWSToqINyJiUa1A25Z0sKRvRMSCiHhF0g8kfbG3B42ImyPiiSjcJek2STt0CzuxzOsuSTdL2qe3OUTEv0bEv1ZJ478lrWV7rO2lbR8oaT1JK/T29wHQEtQn6hOQI2oTtanjBtV82kHmhYh4vc7Y1VU8+R4snueSindLhvT2oLZ3lXSSindxlirHfaQi5MWIeK3i9lOS1mpmDhEx3/Yeks6Q9BNJv5H0W0lcsQjIA/WJ+gTkiNpEbeo4mrOBK7rdfk0V737Y/kDFvnmSFkn6SEQ829cD2l5W0nWSvizphoh4y/av9O7T5KvaHlZRZEZKmtqsHLqU7yx9vMxrqKQnJJ3Z6LgAmoL6RH0CckRtojZ1HNMaB4+/SPqI7TG2l5N0cteOiFgi6QIVc5zXkCTba9vepcZ4tr1c5ZekZSQtq+IDpG+X7wTt3MN9T7G9jO0dVMyxvqaPOdRKbvPytPzKKt4FmhURv+nLWABajvpEfQJyRG2iNrUdzdkgERGPSfqeilPUj0vqvtbGsZJmSPqj7ZfLuI1U3bYq3q3p/nWUpKslvSjpSyouy1ppTrnvOUmXSzosIqb3NgcXVyM6v0Z+31LxjtIzkkZI2rNGLIAOoj5Rn4AcUZuoTZ3giO5ncAEAAAAA7caZMwAAAADIAM0ZAAAAAGSA5gwAAAAAMkBzBgAAAAAZoDlDku1LbJ9W/ryD7Uf7OM75tk9sbnYABitqE4AcUZvQCJqzAcL2TNuLbL9qe67tn9tesdnHiYh7IqLWZWK78hln+12XnI2IwyLi1GbnlMjjd7ajXEwRQJtRm6rmQW0COojaVDUPalOH0ZwNLJ+LiBUlfUzFCu/f6R4wmJ5stveTNGh+XyBj1KYK1CYgG9SmCtSmPNCcDUAR8aykWyVtIknlOyBH2H5cxSKKsr277YdsL7T937Y/2nX/coX4KbZfsX2VpOUq9u1ke1bF7XVtX2/7BdvzbZ9r+8OSzpe0TfmO1MIy9h+n+cvbB9ueYXuB7Rttr1WxL2wfZvtx2y/a/olt1/sY2F5F0kkqFlQEkAFqE7UJyBG1idqUE5qzAcj2upJ2k/Tnis2fl7SVpI1tf0zSxZIOlfR+ST+TdKPtZW0vI+lXki6TtJqkayT9S5XjDJF0k6SnJI2WtLakKyNimqTDJP0hIlaMiPf1cN//Lel0SfuoWIX+KUlXdgvbXcU7WZuVcbuU9x1ZFseRNR6GH0g6T9KcGjEA2ojaJInaBGSH2iSJ2pQNmrOB5Vfluy33SrpLxROty+kRsSAiFkk6WNLPIuL+iFgcEZdKekPS1uXX0pLOiYi3IuJaSQ9UOd6WktaS9O8R8VpEvB4R91aJ7W4/SRdHxJSIeEPSt1W8YzS6ImZCRCyMiKcl3SlpjCRFxNMR8b5y+3vY3kLSdpL+o85cALQWtUnUJiBD1CZRm3LDvNKB5fMR8dsq+56p+HmUpANtf71i2zIqCkZIejYiomLfU1XGXFfSUxHxdh9yXUvSlK4bEfGq7fkq3kWaWW6ufPfmfyQlP6hreylJP5U0PiLe7sUZfQCtQ22iNgE5ojZRm7LDmbPBo7JoPCPp++W7KF1fK0TELyXNlrR2t3nK1U6DPyNppHv+sGz0sK3ScyqKnSTJ9jAVUwWeTf0iCStL2kLSVbbn6J13r2bZ3qHBsQE0H7WJ2gTkiNpEbeoImrPB6QJJh9neyoVhtj9reyVJf5D0tqSjbA+1vZeK0/A9+ZOKojShHGM529uV++ZKWqeci92TKyQdZHuM7WVVTCW4PyJmNvi7vaTi3aUx5ddu5fZ/knR/g2MDaC1qE4AcUZvQNjRng1BETFYxf/pcSS9KmiFpXLnvTUl7lbdflLSvpOurjLNY0uckrS/paUmzynhJ+p2kv0qaY3teD/e9Q9KJkq5TUajWk/TFevIvP9j6ak8fbI3CnK4vSS+Uu+aWvxuATFGbAOSI2oR28runyAIAAAAAOoEzZwAAAACQAZozAAAAAMgAzRkAAAAAZIDmDAAAAAAyQHMGAAAAABnoaRG8lrHNpSGBASginI7KF7UJGLDmRcTqnU6iEdQnYGCq9tqpoTNntj9j+1HbM2wf18hYANBM1CcAkp7qdALdUZsA1NLn5sz2EEk/kbSrpI0ljbW9cbMSA4C+oj4ByBG1CUBKI2fOtpQ0IyKeLFcQv1LSHs1JCwAaQn0CkCNqE4CaGmnO1pb0TMXtWeW2d7F9iO3Jtic3cCwA6I1kfaI2AegAXjsBqKmRC4L09CG293xoNSImSpoo8aFWAG2TrE/UJgAdwGsnADU1cuZslqR1K26vI+m5xtIBgKagPgHIEbUJQE2NNGcPSNrA9gdtLyPpi5JubE5aANAQ6hOAHFGbANTU52mNEfG27SMl/UbSEEkXR8Rfm5YZAPQR9QlAjqhNAFIc0b6pzMybBgYmFqEGkKkHI2KLTifRCOoTMDC1ZBFqAAAAAEBz0JwBAAAAQAZozgAAAAAgAzRnAAAAAJABmjMAAAAAyADNGQAAAABkgOYMAAAAADJAcwYAAAAAGaA5AwAAAIAM0JwBAAAAQAZozgAAAAAgAzRnAAAAAJABmjMAAAAAyADNGQAAAABkgOYMAAAAADJAcwYAAAAAGaA5AwAAAIAM0JwBAAAAQAZozgAAAAAgAzRnAAAAAJABmjMAAAAAyADNGQAAAABkgOYMAAAAADJAcwYAAAAAGaA5AwAAAIAM0JwBAAAAQAZozgAAAAAgAzRnAAAAAJABmjMAAAAAyADNGQAAAABkgOYMAAAAADJAcwYAAAAAGaA5AwAAAIAMDO10AhiYVl999WTMsccem4w55phjkjHTp09Pxlx88cXJmDPOOCMZAwAAALQKZ84AAAAAIAMNnTmzPVPSK5IWS3o7IrZoRlIA0CjqE4AcUZsA1NKMaY2fjIh5TRgHAJqN+gQgR9QmAD1iWiMAAAAAZKDR5iwk3Wb7QduH9BRg+xDbk21PbvBYANAbNesTtQlAh/DaCUBVjU5r3C4inrO9hqTbbU+PiLsrAyJioqSJkmQ7GjweANSrZn2iNgHoEF47AaiqoTNnEfFc+f15SZMkbdmMpACgUdQnADmiNgGopc/Nme1htlfq+lnSzpKmNisxAOgr6hOAHFGbAKQ0Mq1xTUmTbHeNc0VE/FdTskL21ltvvZr7H3/88eQYEemZGvXEjBo1Khmz/vrrJ2MwoFCfmmSZZZapuf+iiy5KjrH//vsnY+p5rtfjv/6r9p95n332SY7x6quvNiUXoAfUJgA19bk5i4gnJW3WxFwAoCmoTwByRG0CkMKl9AEAAAAgAzRnAAAAAJABmjMAAAAAyADNGQAAAABkgOYMAAAAADJAcwYAAAAAGaA5AwAAAIAMNLIINQaoo48+Ohlz2GGHNXychQsXJmNOPfXUZMxNN92UjJkxY0Y9KQHo5ic/+UnN/fvtt19yjMceeywZM2nSpGTM2LFjkzFjxoypuX/atGnJMS688MJkzGmnnZaMWbx4cTIGALrsscceyZiRI0cmY3bcccdkzF577ZWMOf/885MxEydOrLn/L3/5S3IMvBtnzgAAAAAgAzRnAAAAAJABmjMAAAAAyADNGQAAAABkgOYMAAAAADJAcwYAAAAAGaA5AwAAAIAM0JwBAAAAQAYcEe07mN2+g6FH9Szq/K1vfSsZM3Ro7fXLb7zxxuQYX//615Mxs2bNSsag8yLCnc6hEdSm6qZPn15z/4YbbpgcY/3110/GPPnkk3XnVMtKK61Uc/+ECROSYxx++OHJmDPPPDMZU8+x5s+fn4xBQx6MiC06nUQjqE+dt/HGGydjRo0alYz5zne+U3P/pptumhxjhRVWSMbY6f+Sm/X6f968eTX3f+ADH2jKcQaiaq+dOHMGAAAAABmgOQMAAACADNCcAQAAAEAGaM4AAAAAIAM0ZwAAAACQAZozAAAAAMgAzRkAAAAAZIB1zgaQU045JRnz7W9/OxkzZMiQZMyFF15Yc/+RRx6ZHOOtt95KxqB/YJ2z/mnrrbdOxtx3330199ezns6wYcOSMYsWLUrGNEM9+X7wgx9MxlxwwQXJmHrWI5o0aVIyZu7cuTX3X3rppckxBjHWORvE6qk9m222WTLmsssuS8aMHj06GdOu19ztXOcspZ41bc8777w2ZJIf1jkDAAAAgIzRnAEAAABABmjOAAAAACADNGcAAAAAkAGaMwAAAADIAM0ZAAAAAGSA5gwAAAAAMkBzBgAAAAAZYBHqfmKXXXZJxtSzSOLw4cOTMUcccUQypr8tGPjjH/84GbPPPvvU3H/YYYclx7j11lvrzmkgYRHq/mnUqFHJmAcffLDm/tVWWy05xiGHHJKMSS1s3x/96U9/SsZssUV6feTXXnut5v5tttkmOcbUqVOTMQMUi1APYKnFlidOnJgc46CDDmpLLtLgXIT6kUceScZ8+tOfTsbMmzevGelkhUWoAQAAACBjyebM9sW2n7c9tWLbarZvt/14+X3V1qYJAO9FfQKQI2oTgL6q58zZJZI+023bcZLuiIgNJN1R3gaAdrtE1CcA+blE1CYAfZBsziLibkkLum3eQ9Kl5c+XSvp8c9MCgDTqE4AcUZsA9NXQPt5vzYiYLUkRMdv2GtUCbR8iKf1pcABojrrqE7UJQJvx2glAUl+bs7pFxERJEyWuOAQgH9QmALmiPgGDV1+v1jjX9ghJKr8/37yUAKAh1CcAOaI2AUjqa3N2o6QDy58PlHRDc9IBgIZRnwDkiNoEICk5rdH2LyXtJGm47VmSTpI0QdLVtr8q6WlJe7cyycFg5513rrn/Rz/6UXKM97///cmYE088MRnz85//PBmTkwMOOCAZc9RRRyVjll566Zr7N9100+QYg3UR6k6hPjXmqaeeSsY88MADNffvsssuyTHqWQR+xowZyZjf//73yZiB6J577qm5fxAvMJ0talPj6llI+aqrrqq5f6+99mpWOuijdi12PZAkm7OIGFtl1z83ORcA6BXqE4AcUZsA9FVfpzUCAAAAAJqI5gwAAAAAMkBzBgAAAAAZoDkDAAAAgAzQnAEAAABABmjOAAAAACADNGcAAAAAkIHkOmdo3OjRo5Mxl156ac39a665ZnKMO+64Ixlz1llnJWNef/31ZEy7bLTRRsmYiRMnJmOGDm38n/pLL73U8BhAfzNu3Lia+6dPn54cY5VVVknGnH766cmYXXfdNRmzcOHCZEwzrLXWWsmYkSNHNuVY119/fVPGAXIxbNiwZMw555yTjGGR6fzV8xpt3rx5bcik/+DMGQAAAABkgOYMAAAAADJAcwYAAAAAGaA5AwAAAIAM0JwBAAAAQAZozgAAAAAgAzRnAAAAAJABmjMAAAAAyACLULfBwQcfnIxZY401au6/7777kmPsu+++yZhFixYlY9plww03TMbUs/jqMsss04x0ko/NzTff3JTjAP3J3Llza+4/99xzk2Mcf/zxyZitttoqGXPDDTckY0444YSa++tZNHudddZJxlx22WXJmFRdl6Rp06YlY6666qpkDNCfnHLKKcmYgw46qA2ZoNXOP//8TqfQ73DmDAAAAAAyQHMGAAAAABmgOQMAAACADNCcAQAAAEAGaM4AAAAAIAM0ZwAAAACQAZozAAAAAMgA65y1wXbbbdfwGNdcc00yZsGCBQ0fp1nGjh2bjJk4cWIyZoUVVmhGOnVJrak2a9asNmUC9B8nnnhiMmbJkiXJmPHjxydjdthhh2TM3XffnYzJST3rPb3yyittyARonw9/+MOdTgFNcu2113Y6hQGHM2cAAAAAkAGaMwAAAADIAM0ZAAAAAGSA5gwAAAAAMkBzBgAAAAAZoDkDAAAAgAzQnAEAAABABmjOAAAAACADLELdBmuttVYyxnbN/ffee2+z0mmK1CLTV1xxRXKMxYsXJ2PqWbx2yJAhyZh63HXXXU0ZB8C7nXTSScmYW265JRlz8MEHJ2O+8pWv1JVTO9RTvxYuXNj6RIDMjBs3Lhlz2223JWM++tGPNiGb5lhqqfT5jnpqQjO0M5fcXp8OBJw5AwAAAIAMJJsz2xfbft721IptJ9t+1vZD5ddurU0TAN6L+gQgR9QmAH1Vz5mzSyR9poftZ0fEmPIrPR8FAJrvElGfAOTnElGbAPRBsjmLiLslLWhDLgDQK9QnADmiNgHoq0Y+c3ak7YfLU/erVguyfYjtybYnN3AsAOiNZH2iNgHoAF47Aaipr83ZeZLWkzRG0mxJZ1YLjIiJEbFFRGzRx2MBQG/UVZ+oTQDajNdOAJL61JxFxNyIWBwRSyRdIGnL5qYFAH1DfQKQI2oTgHr0qTmzPaLi5p6SplaLBYB2oj4ByBG1CUA9HBG1A+xfStpJ0nBJcyWdVN4eIykkzZR0aETMTh7Mrn2wAeqss85KxowfP77m/s9+9rPJMaZPn56M+eQnP5mM2W677ZIxBxxwQM39b7zxRnKMm2++ORmz/fbbJ2PqWeS7nsUsd91112QMehYRtVdRb5Fm1afBWpv6m/e9733JmM0337zm/i984QvJMQ4//PB6U6rpyiuvTMZ86UtfasqxUNWDnZgayGunxg0fPjwZM2fOnDZkUh87/d9g6jV3szQrl6997WvJmEmTJtXc/9JLLyXHGKyqvXYaWscdx/aw+aKGMwKABlGfAOSI2gSgrxq5WiMAAAAAoElozgAAAAAgAzRnAAAAAJABmjMAAAAAyADNGQAAAABkgOYMAAAAADJAcwYAAAAAGUguQt3Ugw3ShRQ322yzZMytt95ac//yyy+fHGPllVeuO6dGPfLIIzX3H3roockxttlmm2TMmWeeWXdOtWy77bbJmPvvv78pxxqMOrUIdbMM1to0GK2yyirJmBdffLEpx9p7772TMdddd11TjoWqOrIIdTMN1vpUz0LKp512Ws39e+21V1Nyufbaa5Mx9913XzLmggsuqLl/xIgRdedUSz2P3d///vdkzLhx45Ix9957bz0poQfVXjtx5gwAAAAAMkBzBgAAAAAZoDkDAAAAgAzQnAEAAABABmjOAAAAACADNGcAAAAAkAGaMwAAAADIAM0ZAAAAAGSARagzsckmm9Tcf/XVVyfHGDZsWDLmoosuSsY88cQTyZhf/vKXNfcvu+yyyTH+/Oc/J2M22GCDZMwf//jHZMwOO+yQjFmyZEkyBj1jEWr0F+1chHrLLbdMxkyePLkpx0JVLEKNbDz66KM196+33npNOU49i1BvuOGGyZh6Xg+i71iEGgAAAAAyRnMGAAAAABmgOQMAAACADNCcAQAAAEAGaM4AAAAAIAM0ZwAAAACQAZozAAAAAMgAzRkAAAAAZGBopxNAYerUqTX3jxkzJjnGkCFDkjGLFi2qN6WGjBo1KhlTzwLT9fjDH/6QjGGBaQCStPvuuzdlnHpqCnUHQKXU4tD1LB5dj3PPPTcZwwLT+eLMGQAAAABkgOYMAAAAADJAcwYAAAAAGaA5AwAAAIAM0JwBAAAAQAZozgAAAAAgAzRnAAAAAJAB1jnrJ958881Op9ArW2+9dTKmnvU8FixYkIyZMGFCXTkBwPDhw5syzt/+9rdkzJQpU5pyLAD5Gz16dDJm+eWXr7k/IpqSS7PGQWdw5gwAAAAAMpBszmyva/tO29Ns/9X2+HL7arZvt/14+X3V1qcLAAVqE4BcUZ8A9FU9Z87elvTNiPiwpK0lHWF7Y0nHSbojIjaQdEd5GwDahdoEIFfUJwB9kmzOImJ2REwpf35F0jRJa0vaQ9KlZdilkj7fohwB4D2oTQByRX0C0Fe9uiCI7dGSNpd0v6Q1I2K2VBQh22tUuc8hkg5pME8AqIraBCBX1CcAvVF3c2Z7RUnXSTo6Il6u50p7khQREyVNLMfg8jEAmoraBCBX1CcAvVXX1RptL62iuFweEdeXm+faHlHuHyHp+dakCAA9ozYByBX1CUBf1HO1Rku6SNK0iDirYteNkg4sfz5Q0g3NTw8AekZtApAr6hOAvqpnWuN2kg6Q9Ijth8ptx0uaIOlq21+V9LSkvVuSIfqlD33oQ8mYehZJvOmmm5Ix8+bNqysnDDjUJvTavvvu2+kUMDhQnwaQ1VdfPRnz61//OhkzYsSIZqSTNH/+/LYcB62RbM4i4l5J1SZJ/3Nz0wGA+lCbAOSK+gSgr+r6zBkAAAAAoLVozgAAAAAgAzRnAAAAAJABmjMAAAAAyADNGQAAAABkgOYMAAAAADJAcwYAAAAAGahnEWqg14YOTf/TWrhwYTLmuOOOa0I2AFBYbrnlmjLOLbfc0pRxAOTvhBNOSMZsvPHGyZiIaEY6SaeeempbjoPW4MwZAAAAAGSA5gwAAAAAMkBzBgAAAAAZoDkDAAAAgAzQnAEAAABABmjOAAAAACADNGcAAAAAkAGaMwAAAADIAItQoyUee+yxZEw9i1DPmTOnCdkAQHNde+21nU4BQJvYTsYstVT6fMeSJUsazmX8+PENj4G8ceYMAAAAADJAcwYAAAAAGaA5AwAAAIAM0JwBAAAAQAZozgAAAAAgAzRnAAAAAJABmjMAAAAAyADNGQAAAABkgEWo0RJTpkxJxowcOTIZc/bZZydjvvGNb9SVEwA0y9///vdOpwCgCUaPHp2M2X///ZMx9SwwHRE198+cOTM5xmWXXZaMQf/GmTMAAAAAyADNGQAAAABkgOYMAAAAADJAcwYAAAAAGaA5AwAAAIAM0JwBAAAAQAZozgAAAAAgAzRnAAAAAJABFqFGSzz88MPJmKWXXroNmQDAO2699dZkzGuvvZaMefnll5uRDoAOe+GFF5Ix1113XTLmE5/4RDJm5MiRNfe/9dZbyTFeeumlZAz6t+SZM9vr2r7T9jTbf7U9vtx+su1nbT9Ufu3W+nQBoEBtApAr6hOAvqrnzNnbkr4ZEVNsryTpQdu3l/vOjogzWpceAFRFbQKQK+oTgD5JNmcRMVvS7PLnV2xPk7R2qxMDgFqoTQByRX0C0Fe9uiCI7dGSNpd0f7npSNsP277Y9qpV7nOI7cm2JzeWKgD0jNoEIFfUJwC9UXdzZntFSddJOjoiXpZ0nqT1JI1R8e7QmT3dLyImRsQWEbFF4+kCwLtRmwDkivoEoLfqas5sL62iuFweEddLUkTMjYjFEbFE0gWStmxdmgDwXtQmALmiPgHoi3qu1mhJF0maFhFnVWwfURG2p6SpzU8PAHpGbQKQK+oTgL5yRNQOsLeXdI+kRyQtKTcfL2msitPyIWmmpEPLD8DWGqv2wQD0SxHhdh+T2gSgDg92Ymog9Qk9efTRR2vuv/rqq5NjnHjiic1KBx1W7bVTPVdrvFdST3e+pdGkAKCvqE0AckV9AtBXvbpaIwAAAACgNWjOAAAAACADNGcAAAAAkAGaMwAAAADIAM0ZAAAAAGSA5gwAAAAAMkBzBgAAAAAZSK5zBgAAAKAxG220UadTQD/AmTMAAAAAyADNGQAAAABkgOYMAAAAADJAcwYAAAAAGaA5AwAAAIAM0JwBAAAAQAZozgAAAAAgAzRnAAAAAJCBdi9CPU/SUxW3h5fb+gvybS3yba1W5TuqBWO2W/faJPH3bTXybS3yLQzE+sTftrXIt7XIt1C1NjkiWnC8+tieHBFbdCyBXiLf1iLf1upv+XZaf3u8yLe1yLe1+lu+ndTfHivybS3yba1O5Mu0RgAAAADIAM0ZAAAAAGSg083ZxA4fv7fIt7XIt7X6W76d1t8eL/JtLfJtrf6Wbyf1t8eKfFuLfFur7fl29DNnAAAAAIBCp8+cAQAAAABEcwYAAAAAWehYc2b7M7YftT3D9nGdyqNetmfafsT2Q7Yndzqf7mxfbPt521Mrtq1m+3bbj5ffV+1kjpWq5Huy7WfLx/gh27t1MsdKtte1faftabb/ant8uT3Lx7hGvtk+xrmgNjUXtam1qE2DC/WpuahPrUNtaiCXTnzmzPYQSY9J+rSkWZIekDQ2Iv7W9mTqZHumpC0iIsuF82zvKOlVSb+IiE3KbT+StCAiJpRFfNWIOLaTeXapku/Jkl6NiDM6mVtPbI+QNCIiptheSdKDkj4vaZwyfIxr5LuPMn2Mc0Btaj5qU2tRmwYP6lPzUZ9ah9rUd506c7alpBkR8WREvCnpSkl7dCiXASEi7pa0oNvmPSRdWv58qYp/ZFmokm+2ImJ2REwpf35F0jRJayvTx7hGvqiN2tRk1KbWojYNKtSnJqM+tQ61qe861ZytLemZituzlH9xDkm32X7Q9iGdTqZOa0bEbKn4RydpjQ7nU48jbT9cnrrP4lR3d7ZHS9pc0v3qB49xt3ylfvAYdxC1qT2yf970IPvnDbVpwKM+tUf2z50eZP3coTb1TqeaM/ewLfdr+m8XER+TtKukI8pTy2iu8yStJ2mMpNmSzuxoNj2wvaKk6yQdHREvdzqflB7yzf4x7jBqE3qS/fOG2jQoUJ/Qk6yfO9Sm3utUczZL0roVt9eR9FyHcqlLRDxXfn9e0iQV0wtyN7ecQ9s1l/b5DudTU0TMjYjFEbFE0gXK7DG2vbSKJ+zlEXF9uTnbx7infHN/jDNAbWqPbJ83Pcn9eUNtGjSoT+2R7XOnJzk/d6hNfdOp5uwBSRvY/qDtZSR9UdKNHcolyfaw8sOBsj1M0s6Spta+VxZulHRg+fOBkm7oYC5JXU/W0p7K6DG2bUkXSZoWEWdV7MryMa6Wb86PcSaoTe2R5fOmmpyfN9SmQYX61B5ZPneqyfW5Q21qIJdOXK1RklxcivIcSUMkXRwR3+9IInWw/SEV7/hI0lBJV+SWr+1fStpJ0nBJcyWdJOlXkq6WNFLS05L2jogsPkhaJd+dVJw2DkkzJR3aNS+502xvL+keSY9IWlJuPl7FfOTsHuMa+Y5Vpo9xLqhNzUVtai1q0+BCfWou6lPrUJsayKVTzRkAAAAA4B0dW4QaAAAAAPAOmjMAAAAAyADNGQAAAABkgOYMAAAAADJAcwYAAAAAGaA5AwAAAIAM0JwBAAAAQAb+P0D8DkcOL1qpAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 1080x432 with 3 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x432 with 3 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import torch\n",
    "import torch.nn as nn\n",
    "from torch.optim import Optimizer\n",
    "from torch.utils.data import DataLoader\n",
    "from torchvision import datasets\n",
    "from torchvision.transforms import transforms\n",
    "from random import shuffle\n",
    "\n",
    "\n",
    "'''\n",
    "Step 1: (same step)\n",
    "'''\n",
    "# Use data with only 4 and 9 as labels: which is hardest to classify\n",
    "label_1, label_2 = 4, 9\n",
    "\n",
    "# MNIST training data\n",
    "train_set = datasets.MNIST(root='./mnist_data/', train=True, transform=transforms.ToTensor(), download=True)\n",
    "\n",
    "# Use data with two labels\n",
    "idx = (train_set.targets == label_1) + (train_set.targets == label_2)\n",
    "train_set.data = train_set.data[idx]\n",
    "train_set.targets = train_set.targets[idx]\n",
    "train_set.targets[train_set.targets == label_1] = -1\n",
    "train_set.targets[train_set.targets == label_2] = 1\n",
    "\n",
    "# MNIST testing data\n",
    "test_set = datasets.MNIST(root='./mnist_data/', train=False, transform=transforms.ToTensor())\n",
    "\n",
    "# Use data with two labels\n",
    "idx = (test_set.targets == label_1) + (test_set.targets == label_2)\n",
    "test_set.data = test_set.data[idx]\n",
    "test_set.targets = test_set.targets[idx]\n",
    "test_set.targets[test_set.targets == label_1] = -1\n",
    "test_set.targets[test_set.targets == label_2] = 1\n",
    "    \n",
    "\n",
    "'''\n",
    "Step 2: (same step)\n",
    "'''\n",
    "class LR(nn.Module) :\n",
    "    '''\n",
    "    Initialize model\n",
    "        input_dim : dimension of given input data\n",
    "    '''\n",
    "    # MNIST data is 28x28 images\n",
    "    def __init__(self, input_dim=28*28) :\n",
    "        super().__init__()\n",
    "        self.linear = nn.Linear(input_dim, 1, bias=False)\n",
    "\n",
    "    ''' forward given input x '''\n",
    "    def forward(self, x) :\n",
    "        return self.linear(x.float().view(-1, 28*28))\n",
    "\n",
    "'''\n",
    "Step 3: (same step)\n",
    "'''\n",
    "model = LR()                                   # Define a Neural Network Model\n",
    "\n",
    "def logistic_loss(output, target):\n",
    "    return -torch.nn.functional.logsigmoid(target*output)\n",
    "\n",
    "loss_function = logistic_loss                                                   # Specify loss function\n",
    "optimizer = torch.optim.SGD(model.parameters(), lr=255*1e-4)   # specify SGD with learning rate\n",
    "\n",
    "    \n",
    "'''\n",
    "Step 4: Train model with SGD (LOOK HERE)\n",
    "'''\n",
    "\n",
    "# shuffled cyclic SGD\n",
    "train_loader = DataLoader(dataset=train_set, batch_size=1, shuffle=True)\n",
    "\n",
    "import time\n",
    "start = time.time()\n",
    "# Train the model (single epoch)\n",
    "for image, label in train_loader :\n",
    "\n",
    "    # Clear previously computed gradient\n",
    "    optimizer.zero_grad()\n",
    "\n",
    "    # then compute gradient with forward and backward passes\n",
    "    train_loss = loss_function(model(image), label.float())\n",
    "    train_loss.backward()\n",
    "\n",
    "    # perform SGD step (parameter update)\n",
    "    optimizer.step()    \n",
    "end = time.time()\n",
    "print(f\"Time ellapsed in training is: {end-start}\")\n",
    "\n",
    "'''\n",
    "Step 5: (same step)\n",
    "'''\n",
    "test_loss, correct = 0, 0\n",
    "misclassified_ind = []\n",
    "correct_ind = []\n",
    "\n",
    "# Test data\n",
    "test_loader = DataLoader(dataset=test_set, batch_size=1, shuffle=False)\n",
    "# no need to shuffle test data\n",
    "\n",
    "# Evaluate accuracy using test data\n",
    "for ind, (image, label) in enumerate(test_loader) :\n",
    "\n",
    "    # Forward pass\n",
    "    output = model(image)\n",
    "\n",
    "    # Calculate cumulative loss\n",
    "    test_loss += loss_function(output, label.float()).item()\n",
    "\n",
    "    # Make a prediction\n",
    "    if output.item() * label.item() >= 0 : \n",
    "        correct += 1\n",
    "        correct_ind += [ind]\n",
    "    else:\n",
    "        misclassified_ind += [ind]\n",
    "\n",
    "# Print out the results\n",
    "print('[Test set] Average loss: {:.4f}, Accuracy: {}/{} ({:.2f}%)\\n'.format(\n",
    "        test_loss /len(test_loader), correct, len(test_loader),\n",
    "        100. * correct / len(test_loader)))\n",
    "\n",
    "'''\n",
    "Step 6: (same step)\n",
    "''' \n",
    "# Misclassified images\n",
    "shuffle(misclassified_ind)\n",
    "fig = plt.figure(1, figsize=(15, 6))\n",
    "fig.suptitle('Misclassified Figures', fontsize=16)\n",
    "\n",
    "for k in range(3) :\n",
    "    image = test_set.data[misclassified_ind[k]].cpu().numpy().astype('uint8')\n",
    "    ax = fig.add_subplot(1, 3, k+1)\n",
    "    true_label = test_set.targets[misclassified_ind[k]]\n",
    "\n",
    "    if true_label == -1 :\n",
    "        ax.set_title('True Label: {}\\nPrediction: {}'.format(label_1, label_2))\n",
    "    else :\n",
    "        ax.set_title('True Label: {}\\nPrediction: {}'.format(label_2, label_1))\n",
    "    plt.imshow(image, cmap='gray')\n",
    "plt.show()\n",
    "\n",
    "# Correctly classified images\n",
    "shuffle(correct_ind)\n",
    "fig = plt.figure(2, figsize=(15, 6))\n",
    "fig.suptitle('Correctly-classified Figures', fontsize=16)\n",
    "\n",
    "for k in range(3) :\n",
    "    image = test_set.data[correct_ind[k]].cpu().numpy().astype('uint8')\n",
    "    ax = fig.add_subplot(1, 3, k+1)\n",
    "    true_label = test_set.targets[correct_ind[k]]\n",
    "\n",
    "    if true_label == -1 :\n",
    "        ax.set_title('True Label: {}\\nPrediction: {}'.format(label_1, label_1))\n",
    "    else :\n",
    "        ax.set_title('True Label: {}\\nPrediction: {}'.format(label_2, label_2))\n",
    "    plt.imshow(image, cmap='gray')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Running multiple epochs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Time ellapsed in training is: 12.343320608139038\n",
      "[Test set] Average loss: 0.0893, Accuracy: 1922/1991 (96.53%)\n",
      "\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x432 with 3 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x432 with 3 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import torch\n",
    "import torch.nn as nn\n",
    "from torch.optim import Optimizer\n",
    "from torch.utils.data import DataLoader\n",
    "from torchvision import datasets\n",
    "from torchvision.transforms import transforms\n",
    "import matplotlib.pyplot as plt\n",
    "from random import shuffle\n",
    "\n",
    "'''\n",
    "Step 1: (same step)\n",
    "'''\n",
    "# Use data with only 4 and 9 as labels: which is hardest to classify\n",
    "label_1, label_2 = 4, 9\n",
    "\n",
    "# MNIST training data\n",
    "train_set = datasets.MNIST(root='./mnist_data/', train=True, transform=transforms.ToTensor(), download=True)\n",
    "\n",
    "# Use data with two labels\n",
    "idx = (train_set.targets == label_1) + (train_set.targets == label_2)\n",
    "train_set.data = train_set.data[idx]\n",
    "train_set.targets = train_set.targets[idx]\n",
    "train_set.targets[train_set.targets == label_1] = -1\n",
    "train_set.targets[train_set.targets == label_2] = 1\n",
    "\n",
    "# MNIST testing data\n",
    "test_set = datasets.MNIST(root='./mnist_data/', train=False, transform=transforms.ToTensor())\n",
    "\n",
    "# Use data with two labels\n",
    "idx = (test_set.targets == label_1) + (test_set.targets == label_2)\n",
    "test_set.data = test_set.data[idx]\n",
    "test_set.targets = test_set.targets[idx]\n",
    "test_set.targets[test_set.targets == label_1] = -1\n",
    "test_set.targets[test_set.targets == label_2] = 1\n",
    "    \n",
    "\n",
    "'''\n",
    "Step 2: (same step)\n",
    "'''\n",
    "class LR(nn.Module) :\n",
    "    '''\n",
    "    Initialize model\n",
    "        input_dim : dimension of given input data\n",
    "    '''\n",
    "    # MNIST data is 28x28 images\n",
    "    def __init__(self, input_dim=28*28) :\n",
    "        super().__init__()\n",
    "        self.linear = nn.Linear(input_dim, 1, bias=False)\n",
    "\n",
    "    ''' forward given input x '''\n",
    "    def forward(self, x) :\n",
    "        return self.linear(x.float().view(-1, 28*28))\n",
    "\n",
    "'''\n",
    "Step 3: (same step)\n",
    "'''\n",
    "model = LR()                                   # Define a Neural Network Model\n",
    "\n",
    "def logistic_loss(output, target):\n",
    "    return -torch.nn.functional.logsigmoid(target*output)\n",
    "\n",
    "loss_function = logistic_loss                                                   # Specify loss function\n",
    "optimizer = torch.optim.SGD(model.parameters(), lr=255*1e-4)   # specify SGD with learning rate\n",
    "\n",
    "\n",
    "\n",
    "'''\n",
    "Step 4: Train model with SGD (LOOK HERE)\n",
    "'''\n",
    "train_loader = DataLoader(dataset=train_set, batch_size=1, shuffle=True)\n",
    "\n",
    "import time\n",
    "start = time.time()\n",
    "# Train the model for 3 epochs\n",
    "for epoch in range(3) :\n",
    "    for image, label in train_loader :\n",
    "        # Clear previously computed gradient\n",
    "        optimizer.zero_grad()\n",
    "\n",
    "        # then compute gradient with forward and backward passes\n",
    "        train_loss = loss_function(model(image), label.float())\n",
    "        train_loss.backward()\n",
    "\n",
    "        # perform SGD step (parameter update)\n",
    "        optimizer.step()\n",
    "end = time.time()\n",
    "print(f\"Time ellapsed in training is: {end-start}\")\n",
    "\n",
    "\n",
    "'''\n",
    "Step 5: (same step)\n",
    "'''\n",
    "test_loss, correct = 0, 0\n",
    "misclassified_ind = []\n",
    "correct_ind = []\n",
    "\n",
    "# Test data\n",
    "test_loader = DataLoader(dataset=test_set, batch_size=1, shuffle=False)\n",
    "# no need to shuffle test data\n",
    "\n",
    "# Evaluate accuracy using test data\n",
    "for ind, (image, label) in enumerate(test_loader) :\n",
    "\n",
    "    # Forward pass\n",
    "    output = model(image)\n",
    "\n",
    "    # Calculate cumulative loss\n",
    "    test_loss += loss_function(output, label.float()).item()\n",
    "\n",
    "    # Make a prediction\n",
    "    if output.item() * label.item() >= 0 : \n",
    "        correct += 1\n",
    "        correct_ind += [ind]\n",
    "    else:\n",
    "        misclassified_ind += [ind]\n",
    "\n",
    "# Print out the results\n",
    "print('[Test set] Average loss: {:.4f}, Accuracy: {}/{} ({:.2f}%)\\n'.format(\n",
    "        test_loss /len(test_loader), correct, len(test_loader),\n",
    "        100. * correct / len(test_loader)))\n",
    "\n",
    "'''\n",
    "Step 6: (same step)\n",
    "''' \n",
    "# Misclassified images\n",
    "shuffle(misclassified_ind)\n",
    "fig = plt.figure(1, figsize=(15, 6))\n",
    "fig.suptitle('Misclassified Figures', fontsize=16)\n",
    "\n",
    "for k in range(3) :\n",
    "    image = test_set.data[misclassified_ind[k]].cpu().numpy().astype('uint8')\n",
    "    ax = fig.add_subplot(1, 3, k+1)\n",
    "    true_label = test_set.targets[misclassified_ind[k]]\n",
    "\n",
    "    if true_label == -1 :\n",
    "        ax.set_title('True Label: {}\\nPrediction: {}'.format(label_1, label_2))\n",
    "    else :\n",
    "        ax.set_title('True Label: {}\\nPrediction: {}'.format(label_2, label_1))\n",
    "    plt.imshow(image, cmap='gray')\n",
    "plt.show()\n",
    "\n",
    "# Correctly classified images\n",
    "shuffle(correct_ind)\n",
    "fig = plt.figure(2, figsize=(15, 6))\n",
    "fig.suptitle('Correctly-classified Figures', fontsize=16)\n",
    "\n",
    "for k in range(3) :\n",
    "    image = test_set.data[correct_ind[k]].cpu().numpy().astype('uint8')\n",
    "    ax = fig.add_subplot(1, 3, k+1)\n",
    "    true_label = test_set.targets[correct_ind[k]]\n",
    "\n",
    "    if true_label == -1 :\n",
    "        ax.set_title('True Label: {}\\nPrediction: {}'.format(label_1, label_1))\n",
    "    else :\n",
    "        ax.set_title('True Label: {}\\nPrediction: {}'.format(label_2, label_2))\n",
    "    plt.imshow(image, cmap='gray')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Using batch update"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Time ellapsed in training is: 5.357270240783691\n",
      "[Test set] Average loss: 0.1748, Accuracy: 1895/1991 (95.18%)\n",
      "\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x432 with 3 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAA2cAAAFoCAYAAADTgoOZAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8rg+JYAAAACXBIWXMAAAsTAAALEwEAmpwYAAAwCUlEQVR4nO3de5wcZZX/8e+Xq8hFwQSIkZsgsOhqgIiXIERRUcQfhFUQb4BAUGBFERWBLKggIAoiChjkkl1RREMAxZWbEEAuGrIRkAQIGEhISEgCCJFbkvP7o2qgGXr6qZnunn4y83m/XvOa6arTVadrps/06Xq6HkeEAAAAAACdtVKnEwAAAAAA0JwBAAAAQBZozgAAAAAgAzRnAAAAAJABmjMAAAAAyADNGQAAAABkgOYMAOqw/R7bl9qea/sF24tsX2t7P9srdzq/qmxvavsE22+us26W7Yv6MZeLbM/qr/112/eNtm/stuw9tu+wvcR22B7R6hzLY5+cs6bML+p8zekpfwDAwLNKpxMAgNzY/oqk0yX9SdI3JT0saV1JH5Z0jqQnJV3RofR6a1NJx0u6RdJDnU2low6ts+x8Sc9K+rikf0m6X9J3JZ3Zj3nVukvSId2WPV9+r5c/AGCAoTkDgBq2d1LRmP0kIr7cbfUVtk+XtGYL9rN6RDxfZ/mqkpZGRPJsC6qLiHtrb9teSdJWkk6KiD/VrHqwXxN7pacj4vZ6K7rn3196+jsFALQHwxoB4JWOlrRY0jfqrYyIByPirq7btnewfZ3tZ8rhcdfb3qH2PuVQuTnlMLpbbT8r6fvlkMOwfajt79ueq+JMyevL++1l+3bb/7L9pO3f2N64e062D7Y91faztp+wPdn2e22PlnRDGXZtzVC50XW2sX25bo8667rybzic0/Zmtv/H9mO2n7f9kO2GZ6Fsf7vM/SnbC23/yfa7u8WsZfss24+U251fHvOta2KOsD295hhMsT2mZv1LwwJt7y9pmYr/gePKxz2r5rHO6rb/19o+1fY/yiGu/7B9bNng1cZta/tm28/ZftT2OElu9Pir6mFY5nY1+5tt+5jyeEZNTNff2P7d7ju6+99CuY9bbH/c9v/Zfl7lGbvyd3ux7cfL38G02uNbxmxpe5LtBWVOj5R/s7wRDAAVUTABoFQ2H6MlXR4Rz1WIf7ukyZLulbS/pFDR3E22/e6I+FtN+OskXSLpB5KOUTGcrsuxkv4qaayklSU9Z/uLKoZQXijpO5LWlnRCue23R8TTZQ4/kPQ1FUP0jpe0XNK7JW0s6Q+SDpP0U0lfLvehMt9XiIg7bf9VxbC6l4Zs2n69pL0lfT8iljU4FptJ+ouK4YHHS3pA0kYqhoI2MlzSGZLmqDgj+VlJN9keWdMEnyHp/6k4bg9IeoOkUXq5if2MpB+Wx+lmSWtIeruk9XrY51WSdlQx1PN8ST/Xy8MHuz+uVSRdLWkbFUMe71ZxfMeV2/9aGTdExTDYxyTtV27v6yp+D5XVaWSW1TuLWu7veklzJX1e0guSvqpiGGsztpT0YxWP9SFJi21vJOkOSQvKfTwuaR9JE23vGRFXlvf9vYohv1+StFDF73Y38UYwAFRGcwYALxui4oX9wxXj/0vFi/BdIuJJSbJ9raRZKhqUvWpi15L02YiobXw2LX+cL2lM14tw22tJOlXShRHxhZr4O1R8LupAST+yvYWKF8tnRMSRNfu6quY+XY3Y9J6GzNU4W9L5tjeJiK5j8HlJq6loYBr5topj946ImFuzfEKjO0XEQTW5rizpj5L+ruIxHlGueo+kiyPi/Jq7Tqr5+T2S7oqI79Qs+0ODfT5u+4ny5pzEcdlXRSO3c0TcVC673rYkHW/71IjoalrWlLRrRDxSPp5rVf1vSSoazhe7LTtY9Y/9kTX767poyNUq/vaaMUTShyNiWtcC2+erOAO4c0QsKhdfXTZt35F0ZdksvkXSHjXNmiT9ssl8AGBQ4d0sAOi7nST9vqsxk6SI+KekKyXt3C12qYozC/Vc3u3syHskrSPpYturdH2pOLs0o9yvJH1QRR0f3+wDKV2i4szHwTXLDpF0VU0DsHJtTi67FBVnyH7frTFLsv1B2zfYXqTiGL2o4uzNVjVhf5W0fzlsb6RfPbzyr5JGlEMfP2j7tb3JIeEjKhqsW7v9Lq6RtKqKs2hS8Tu7vasxk6SIWCLpd73Y198kvbPb1+U9xL5b0m1dv5dyf8+qpjHvo1m1jVnpIyqa3ae6HYOrJb3D9jqSFqk403aKi2G2b2kyDwAYlGjOAOBli1QMN9ykYvx6kubVWf6Yiqs71lrQYFhg922sX36/TkWzUvv17yqG9anm+xy1QDmU80JJB5YvwN+nYjjfuTVhD3bLZ7+aXHqVh+3tVLzof0bFmbJ3q2hI/ibpNTWh/ynpZ5K+oKIRW2D7jJom7L9VDKV7l4qGYbHty2rOTDZjfRV/D91/D38p13f9DoapOAPaXb1lPXkmIqZ0+1rYQ+wwFcMMm9lfPfX+ntdXcQa1+zE4rVz/hvLNhQ9JmiLpZEn3u/jM4ZeazAcABhWGNQJAKSKWlhdd+JCrXaVusaQN6yzfsFz3is032nW3211Dx/ZXMcSvu6fL710v3IdLuq/B9nvjHBVD5vaQNEbFMLmra9Z/XNLqNbf/UZPL8F7u6z9UnC3bKyJeGs5ne10VZ/AkSRHxjKRvSfqW7U0kfULSKSo+Z/XNsjH4maSflff9sIrPoP1aRcPWjEUqHuPePayfVX6fJ2mDOuvrLWuFeXq5iW+0v67PTq7WbfkbVF+9v9NFKj7Ld2oP95krSRHxkKTPl2dT3yHpcEln254VEf/bw30BADVozgDglU6RdKOKswLdL6XfdeGLtcuLVUyW9DHba9dcoGNtFQ3MjU3kcKuKBmyLiGj0ma3rVFwAZKzKC1PU0dVgrlFlxxHxoO1rVFzMYoSk70TE8pr1d/dw12sk7WV7WETUO/tSz2tVXDWx9uqCH1BxEY1/1LtD+Vm4H5YXAXlbnfVPSPq17Xfp1XOG9cUfVTSRz0TEjAZxt0n6uu2NImK2JNleU8XfQjvcLuko22+qGXK6hqSPdYubr+JvoPux6h7XyB9VDNv8ezl0sqGyWZ5m+0gVZ0TfJonmDAAqoDkDgBoRcVP5ovJ02/8m6SJJj6gYpriLpIMkfVrFhMHflbS7igtEnKqiyfimiqbjO6/eeuUc/mn765J+anuoihe2T6k4M7WzpBsj4pdlI3WGpCPLpvBKFc3ODpJmRMSvVVxAZKmkL9herOKF+n1dzWQPzlZxxcYXJV1QMe3jVbzgv9X29yTNLPP9SER8tof7/FHSVyRdZPtCFZ81Gyfp0dog27eVj+1uFUMgd1ZxZmZCuX68imb2NhVD/baU9DkVDWOzLpZ0gIrf8Q9VDLlcTdLmKq4guWdE/EvFFSUPlXSN7RP08tUak81MH52uYijn1ba/Xe7vyPL7S81uRITtX6sYqnq/ijOsH1NxVdKq/kvFMM6bbP9ExdnCdVU0XW+OiC+UVy49U8XZypkqrjq6v4q/vT/V2SYAoA6aMwDoJiJ+ZPsvKq7A9wMVV7B7WsXnaQ5ReZGHiLjLxTxRJ6loFKzijMbO3S6j35ccfmZ7tooX+J9WcfGJRyXdJGlaTdxRtmeqaAz2k7REReN4Tbl+ke3DVTSNk1W8aH6/Gp/Zu0rFJfH/EBGPVcx3Vnm26kQVnzlau8z3igb3udr2l1U0Ff8h6R4Vn206rlvoTSqGFR6t4v/WQ5K+GhE/Ltf/WUUD9TkVUxbMlfQLFQ1jUyLiRdu7lvseK2kzFcf4QRXH6YUybqHtXVQ0KBNUDAU8t8z3v5rNo05eXfv7sYrP3HXtb4iKY1jrCBWfMT+h/H6pis/x9XSBmu77esT2yPL+35M0tNzfPXr5apyPqXgT40hJb1IxnPJuSbtHxJ19eYwAMBi5zvQpAIBBzPaHVDR3H4yI6zudD6opr2I5VdLCiNil0/kAAHqPM2cAAEmS7c0lvVnFEL2pNGZ5s/1dFUMIH1ZxgY+DVEy+vVsn8wIA9B3NGQCgyzhJn1XxuaruQ+OQn1AxZPKN5c93qfgMHBffAIAVFMMaAQAAACADTEINAAAAABmgOQMAAACADNCcAQAAAEAGaM4AAAAAIAM0ZwAAAACQAZozAAAAAMgAzRkAAAAAZIDmDAAAAAAyQHMGAAAAABmgOQMAAACADNCcAQAAAEAGaM4AAAAAIAM0ZwAAAACQAZozAAAAAMgAzRkAAAAAZIDmDAAAAAAyQHMGAAAAABmgOQMAAACADNCcAQAAAEAGaM4AAAAAIAM0ZwAAAACQAZozAAAAAMgAzRkAAAAAZIDmDAAAAAAyQHMGAAAAABmgOQMAAACADNCcAQAAAEAGaM4AAAAAIAM0ZwAAAACQAZozAAAAAMgAzRkAAAAAZIDmDAAAAAAyQHMGAAAAABmgOQMAAACADNCcAQAAAEAGaM4AAAAAIAM0Z+g3tkfbntPf9wWAFOoTgBxRmwYfmrMVmO1nar6W23625vZn2rjf/W3f0q7tt4Lt99r+i+2nbd9le8dO5wQMJtSnNNs72w7bJ3Y6F2CwoDalUZs6a5VOJ4C+i4i1un62PUvSQRFxXfc426tExNL+zK2TbK8n6UpJX5J0maR9Jf3O9psj4omOJgcMEtSnxmyvKulMSXd0OhdgMKE2NUZt6jzOnA1AXaexbX/T9mOSLqz3jk35rsgW5c+r2/6B7Udsz7d9ru01+rDvA2xPL89YPWT7kDoxx9heaHtW7btUrcpB0nslzY+I30TEsoj4haTHJe3Vh20BaCHq00u+JukaSTOa2AaAFqE2vYTa1GE0ZwPXhpLWk7SJpLEV4k+VtKWkEZK2kDRc0n/1Yb8LJO0uaR1JB0g6w/Z23fIaUm5/P0njbW/V2xxsn2377B5ycPnVfdnbevtgALTFYK5Psr2JpC9I+k4fHgOA9qE2UZs6juZs4Fou6fiIeD4inm0UaNuSDpb01YhYHBFPS/qepE/1dqcRcVVEPBiFySrefXlft7BxZV6TJV0lae/e5hARh0bEoT2kcaukN9re1/aqtveTtLmk1/b28QBoi8FcnyTpx+V+nuntYwDQVtQmalPH8ZmzgevxiHiuYuxQFY3LncXzXFJxpmnl3u7U9kclHa/iXZyVyu3eXRPyREQsqbn9sKQ3tjKHiFhkew9JP5D0U0lXS7pOElcsAvIwaOuT7Y9LWjsift3b+wJoO2oTtanjaM4Gruh2e4lqzhzZ3rBm3UJJz0p6a0Q82tcd2l5d0kRJn5d0RUS8aPtyvXKI4bq216wpMhtLuqdVOXQp31l6Z5nXKpIelPTDZrcLoCUGc33aRdLI8jMtkvQ6Scts/3tE7NHktgE0h9pEbeo4hjUOHn+T9FbbI2y/RtIJXSsiYrmk81SMcV5fkmwPt71rg+3Z9mtqvyStJml1FRffWFq+E/ThOvf9tu3VbL9PxRjr3/Qxh0bJbVsOaVxHxRm0ORFxdV+2BaDtBlN9GqeXPx8yQsWVZc9T8TkTAHmhNlGb+h3N2SAREfer+IDndZIekNR9ro1vSpop6Xbb/yzjtlLP3qvi3ZruX1+WdKmkJyR9WsWTu9Zj5bq5ki6W9MWI6LoiUOUcyqsRndsgv2+oeEdptqRhksY0iAXQQYOpPkXE0xHxWNdXmdeSiFjc4PEA6ABqE7WpExzR/QwuAAAAAKC/ceYMAAAAADJAcwYAAAAAGaA5AwAAAIAM0JwBAAAAQAZozpBk+yLbJ5Y/v8/2fX3czrm2x7U2OwCDFbUJQI6oTWgGzdkAYXuW7WdtP2N7vu0Lba/V6v1ExM0R0egysV357G/7FZecjYgvRsR3W51TnX2vbvsM23NtP2H7bNurtnu/AF6N2tRjHn+yHbZX6c/9AihQm3rMg9rUYTRnA8vHI2ItSdtJeqek47oHDJIn29GSRkp6m4oJFbdTnWMBoN9Qm2rY/oykQfN4gYxRm2pQm/JAczYARcSjkv5XRXOi8h2Qw2w/oGISRdne3fY020/avtX227vub3tb21NtP23715JeU7NutO05Nbc3sn2Z7cdtL7L9E9v/JulcSe8p35F6sox96TR/eftg2zNtL7Z9pe031qwL21+0/UB59uuntl3xEHxc0o8jYnFEPC7px5K+0MvDCKDFqE2S7ddJOl7SN3p5+AC0CbWJ2pQTmrMByPZGknaT9H81i/eU9C5J29jeTtIFkg6R9AZJP5N0pYvhgKtJulzS/0haT9JvJP1HD/tZWdLvJT0saVNJwyVdEhHTJX1R0m0RsVZEvL7OfT8g6WRJe0saVm7jkm5hu6t4J+sdZdyu5X03Lovjxj0dgvKr9vabysIDoEOoTZKk70k6R9JjDWIA9CNqkyRqUzZozgaWy8t3W26RNFnFE63LyeWZpGclHSzpZxFxR0Qsi4gJkp6X9O7ya1VJP4qIFyPit5L+2sP+dpD0Rklfj4glEfFcRNzSQ2x3n5F0QURMjYjnJX1LxTtGm9bEnBIRT0bEI5JukDRCkiLikYh4fbm8nv+VdITtobY3lPTlcvlrK+YGoLWoTZJsj5Q0StJZFXMB0F7UJlGbcsO40oFlz4i4rod1s2t+3kTSfrb/s2bZaioKRkh6NCKiZt3DPWxzI0kPR8TSPuT6RklTu25ExDO2F6l4F2lWubj23Zt/Sar6Qd2TJL1e0jQVxfM8SdtKWtCHPAE0b9DXJtsrSTpb0hERsbQXo40AtA+1idqUHc6cDR61RWO2pJPKd1G6vl4bEb+SNE/S8G7jlHs6DT5b0sau/2HZqLOs1lwVxU6SZHtNFUMFHk09kJSIeDYiDo+I4RHxZkmLJN0ZEcua3TaAlhsstWkdFRcq+rXtx/TyO+tzbL+vyW0DaD1qE7WpI2jOBqfzJH3R9rtcWNP2x2yvLek2SUslfdn2Krb3UnEavp6/qChKp5TbeI3tUeW6+So+57VaD/f9paQDbI+wvbqKoQR3RMSsZh+c7eG231g+tndLGqfiQ64A8jaQa9NTKt75HlF+7VYu317SHU1uG0B7UZvQb2jOBqGImKJi/PRPJD0haaak/ct1L0jaq7z9hKR9JF3Ww3aWqbgy4haSHpE0p4yXpD9J+rukx2wvrHPf61U0TRNVFKrNJX2qSv7lB1ufafDB1s0l3SppiaQJko6OiGuqbBtA5wzk2hSFx7q+JD1erppfPjYAmaI2oT/5lUNkAQAAAACdwJkzAAAAAMgAzRkAAAAAZIDmDAAAAAAyQHMGAAAAABmgOQMAAACADNSbBK9tbHNpSGAAigino/JFbQIGrIURMbTTSTSD+gQMTD29dmrqzJntj9i+z/ZM20c3sy0AaCXqEwBJD3c6ge6oTQAa6XNzZntlST+V9FFJ20ja1/Y2rUoMAPqK+gQgR9QmACnNnDnbQdLMiHionEH8Ekl7tCYtAGgK9QlAjqhNABpqpjkbLml2ze055bJXsD3W9hTbU5rYFwD0RrI+UZsAdACvnQA01MwFQep9iO1VH1qNiPGSxkt8qBVAv0nWJ2oTgA7gtROAhpo5czZH0kY1t98kaW5z6QBAS1CfAOSI2gSgoWaas79KeovtzWyvJulTkq5sTVoA0BTqE4AcUZsANNTnYY0RsdT24ZKulrSypAsi4u8tywwA+oj6BCBH1CYAKY7ov6HMjJsGBiYmoQaQqTsjYmSnk2gG9QkYmNoyCTUAAAAAoDVozgAAAAAgAzRnAAAAAJABmjMAAAAAyADNGQAAAABkgOYMAAAAADJAcwYAAAAAGaA5AwAAAIAM0JwBAAAAQAZozgAAAAAgAzRnAAAAAJABmjMAAAAAyADNGQAAAABkgOYMAAAAADJAcwYAAAAAGaA5AwAAAIAM0JwBAAAAQAZozgAAAAAgAzRnAAAAAJABmjMAAAAAyADNGQAAAABkgOYMAAAAADJAcwYAAAAAGaA5AwAAAIAM0JwBAAAAQAZozgAAAAAgAzRnAAAAAJABmjMAAAAAyADNGQAAAABkgOYMAAAAADJAcwYAAAAAGaA5AwAAAIAM0JwBAAAAQAZW6XQCAACsscYayZjRo0cnY2699daG65966qmqKQ0oW2yxRTLm5ptvTsbMnz8/GfOBD3wgGbN48eJkDIC+mTx5cjJm0qRJyZgf/ehHLcgGvcWZMwAAAADIQFNnzmzPkvS0pGWSlkbEyFYkBQDNoj4ByBG1CUAjrRjW+P6IWNiC7QBAq1GfAOSI2gSgLoY1AgAAAEAGmm3OQtI1tu+0PbZegO2xtqfYntLkvgCgNxrWJ2oTgA7htROAHjU7rHFURMy1vb6ka23PiIibagMiYryk8ZJkO5rcHwBU1bA+UZsAdAivnQD0qKkzZxExt/y+QNIkSTu0IikAaBb1CUCOqE0AGulzc2Z7Tdtrd/0s6cOS7mlVYgDQV9QnADmiNgFIaWZY4waSJtnu2s4vI+KPLckKAJpDfVrBnHjiicmYr371q8mY+++/v+H63XffPbmNmTNnJmNysuGGGyZjjjjiiGTMBhtskIypMln4gQcemIw57bTTkjEDFLWphYYOHdpw/ZgxY5LbuOmmm5IxM2bMqJxTu1V5TDvuuGMyZtSoUcmYhx9+OBlTZTJr9E6fm7OIeEjSO1qYCwC0BPUJQI6oTQBSuJQ+AAAAAGSA5gwAAAAAMkBzBgAAAAAZoDkDAAAAgAzQnAEAAABABmjOAAAAACADNGcAAAAAkIFmJqFGP9p4442TMYcffngyZq+99krGbL755smYG2+8seH6L33pS8ltVJnUcZ111knGvP/970/GPProo8mYKVOmJGMA9N6IESOSMdtuu21L9nX99dc3XL+iTTAtSauvvnrD9RMmTEhu40Mf+lBLcrnhhhuSMWeddVZL9gWkpCavP+igg5LbOPPMM5MxRx55ZOWcclBOct60sWPHJmOYhLr1OHMGAAAAABmgOQMAAACADNCcAQAAAEAGaM4AAAAAIAM0ZwAAAACQAZozAAAAAMgAzRkAAAAAZIDmDAAAAAAywCTUmdh1110brv/JT36S3MYGG2yQjKky8fN5552XjDn55JMbrr/22muT23jb296WjLnuuuuSMdtvv30yZt68ecmYbbbZpuH6p556KrkNYLAZNWpUMqbKJKVDhgxJxlSpXyvahKirrJL+N7z33ns3XN+qCaZvv/32ZMyhhx6ajHnuuedakQ6QtOeeezZcHxHJbVx22WUtyqZ/VKlxVR53lZjp06dXygmtxZkzAAAAAMgAzRkAAAAAZIDmDAAAAAAyQHMGAAAAABmgOQMAAACADNCcAQAAAEAGaM4AAAAAIAPMc9YPRo4cmYz57W9/23D9tGnTktvYZ599kjH33XdfMmbp0qXJmFQ+Y8aMSW7j05/+dDKmylxoVQwbNiwZM3z48IbrmecMg9Euu+zScP3555+f3EaVOcyWL1+ejLn00kuTMVXmRszJdtttl4yZMGFC0/tZsGBBMuass85KxlSZMxJohWOPPTYZs/766zdcP3ny5OQ2brnllso55WCnnXZKxthuyb6GDh3aku2gdzhzBgAAAAAZoDkDAAAAgAzQnAEAAABABmjOAAAAACADNGcAAAAAkAGaMwAAAADIAM0ZAAAAAGSA5gwAAAAAMsAk1P1gv/32S8asueaaDddfccUVyW1MnTq1ck7Nuvrqq5taL0m/+93vkjHz589Pxmy88cbJmCq23HLLhuvvvffeluwHyMUBBxyQjDn77LMbrl999dVbkstnP/vZZMwll1zSkn3l5MQTT+yX/Rx++OHJmN/+9rf9kAkgjRkzJhlz9NFHJ2NSk9dPmjSpck4riq233joZExEtiamyL7QeZ84AAAAAIAPJ5sz2BbYX2L6nZtl6tq+1/UD5fd32pgkAr0Z9ApAjahOAvqpy5uwiSR/ptuxoSddHxFskXV/eBoD+dpGoTwDyc5GoTQD6INmcRcRNkhZ3W7yHpAnlzxMk7dnatAAgjfoEIEfUJgB91dcLgmwQEfMkKSLm2V6/p0DbYyWN7eN+AKC3KtUnahOAfsZrJwBJbb9aY0SMlzRekmynLw0DAP2A2gQgV9QnYPDq69Ua59seJknl9wWtSwkAmkJ9ApAjahOApL42Z1dK6pq8az9J6Um4AKB/UJ8A5IjaBCApOazR9q8kjZY0xPYcScdLOkXSpbYPlPSIpE+2M8mc7bzzzsmY4cOHJ2MWLGj8Btq5555bOaccVJnc9sknn0zGtGqC6dTxlaQbb7yxJftC/xms9cl2MmarrbZKxowfPz4Zs/LKKzdcn5oEVpLOOeecZMxll12WjFnRpI6dJI0aNarp/Tz66KPJmGnTpjW9H1Q3WGtTVRMnTkzGVJkkeerUqQ3Xn3nmmZVzGkiq/I9AvpLNWUTs28OqXVqcCwD0CvUJQI6oTQD6qq/DGgEAAAAALURzBgAAAAAZoDkDAAAAgAzQnAEAAABABmjOAAAAACADNGcAAAAAkAGaMwAAAADIQHKeMzR22GGHJWOGDBmSjJk+fXrD9c8880zlnPrDBhts0HD9t7/97eQ25s2b16p0ku6///5kTJVJsYEcbLTRRsmYe++9tx8yka644opkzFe+8pVkzLJly1qQTf9ZY401kjHf+MY3WrKd1ETfv/jFL5LbmDlzZjIGaIUxY8YkY6pMMF0lZiBOXt8KrTq+6AzOnAEAAABABmjOAAAAACADNGcAAAAAkAGaMwAAAADIAM0ZAAAAAGSA5gwAAAAAMkBzBgAAAAAZoDkDAAAAgAwwCXWT/va3vyVjPvGJTyRjFi1a1HD96173uuQ2nnrqqWRMFVX2dd111zVc/6Y3vSm5DdvJmBdeeCEZs9pqqyVjbrvttmQMsKLYddddO53CS6pMOHvJJZckY5YsWZKMqVLjjjjiiGRMK+y0007JmKOOOqol+0r9n/nWt77Vkv0ArbDNNtskY6r8/7/55puTMSeffHKlnAabKse3ijXXXDMZs/322zdcv/HGGye3ccsttyRjxo4dm4w56aSTkjErAs6cAQAAAEAGaM4AAAAAIAM0ZwAAAACQAZozAAAAAMgAzRkAAAAAZIDmDAAAAAAyQHMGAAAAABlwRPTfzuz+21k/qTLH1syZM5MxqXnBJk2alNzGuHHjkjHDhw9Pxnz+859PxnzmM59puL7KvGIf/ehHkzF/+ctfkjFbbrllMuaCCy5Ixhx00EHJGNQXEa2ZVKVDVrTaNHv27GRMlef6iub5559PxqSe64cddlhyG294wxuSMVOmTEnGbLLJJsmY5cuXJ2M++clPNlxf5f/DIHZnRIzsdBLNyKk+DR06NBlT5f92lbmvxo8fn4z51a9+1XB9ledXlXnZqsznWOV5mNrOkCFDktuoElPl+FZ5/V9lvrTUdp599tnkNhYuXNiSmHe+853JmJz09NqJM2cAAAAAkAGaMwAAAADIAM0ZAAAAAGSA5gwAAAAAMkBzBgAAAAAZoDkDAAAAgAzQnAEAAABABmjOAAAAACADq3Q6gRXdCy+8kIw555xzkjFHHXVUw/VVJkCsEtMqCxYsaLj+2GOPTW5jpZXS7w1UmQwWGGyqTDjfn/WgFapMJr/VVlslY/bff/+G66vUlAceeCAZU2WC6SqqTNDKJNPIRZXJjavEVJnceOzYscmYQw45pOH6/ppoWapWE1I1bPbs2S3JpcpjqqLKdmbMmNFw/XHHHZfcxo477piM+drXvpaMGSg4cwYAAAAAGUg2Z7YvsL3A9j01y06w/ajtaeXXbu1NEwBejfoEIEfUJgB9VeXM2UWSPlJn+RkRMaL8+kNr0wKASi4S9QlAfi4StQlAHySbs4i4SdLifsgFAHqF+gQgR9QmAH3VzGfODrd9V3nqft2egmyPtT3F9pQm9gUAvZGsT9QmAB3AaycADfW1OTtH0uaSRkiaJ+mHPQVGxPiIGBkRI/u4LwDojUr1idoEoJ/x2glAUp+as4iYHxHLImK5pPMk7dDatACgb6hPAHJEbQJQRZ+aM9vDam6OkXRPT7EA0J+oTwByRG0CUEVyEmrbv5I0WtIQ23MkHS9ptO0RkkLSLEmNZwEc5E477bRkzEUXXdRw/W67pa+4u/766ydj5s6dm4xZZ511kjHjx49vuP75559PbuPAAw9MxjAJNRoZrPUpVS+qxuRkyJAhyZgDDjggGXPqqac2XL/PPvskt9GfE9eed955yRiseAZqbVq4cGEy5uabb07GvO9970vGVHn+pPY1ffr05DYuv/zyluRyyy23JGO23nrrhusfeeSR5DaqmDx5cjImNSF2VZdddlnD9ZMmTUpuo8rfzGCSbM4iYt86i89vQy4A0CvUJwA5ojYB6KtmrtYIAAAAAGgRmjMAAAAAyADNGQAAAABkgOYMAAAAADJAcwYAAAAAGaA5AwAAAIAM0JwBAAAAQAaS85yheUuXLk3GzJs3r+H6888feNOjpCZjbKWJEyf2274A9F6VyW1PP/30prdz3HHHJbex2WabJWOqTEpbxeLFi1uyHaA/PPzww8mY0aNHJ2PGjh2bjElNbixVqxs5mTp1ar/sp8qkzlVeg9lOxhxzzDEN148bNy65jRXt99hunDkDAAAAgAzQnAEAAABABmjOAAAAACADNGcAAAAAkAGaMwAAAADIAM0ZAAAAAGSA5gwAAAAAMkBzBgAAAAAZYBJqdMwDDzzQb/u6/fbb+21fANpj2bJlyZgLL7yw4frZs2cnt3HNNddUzqmRF198MRlz2mmntWRfwIpk/PjxnU5h0IuIrLaDl3HmDAAAAAAyQHMGAAAAABmgOQMAAACADNCcAQAAAEAGaM4AAAAAIAM0ZwAAAACQAZozAAAAAMgAzRkAAAAAZIBJqNExw4cPb8l2HnzwwWTMkiVLWrIvAHkbNmxYw/XnnXdeS/Zzxx13JGOOOuqoZMzzzz/finQA4CVV6tzBBx+cjLHdinTQS5w5AwAAAIAM0JwBAAAAQAZozgAAAAAgAzRnAAAAAJABmjMAAAAAyADNGQAAAABkgOYMAAAAADLAPGfomJ133rkl25kxY0Yy5oUXXmjJvgDkbauttmq4fpNNNmnJfqrUnT//+c8t2RcAtFpEZLUdvIwzZwAAAACQgWRzZnsj2zfYnm7777aPKJevZ/ta2w+U39dtf7oAUKA2AcgV9QlAX1U5c7ZU0tci4t8kvVvSYba3kXS0pOsj4i2Sri9vA0B/oTYByBX1CUCfJJuziJgXEVPLn5+WNF3ScEl7SJpQhk2QtGebcgSAV6E2AcgV9QlAX/XqgiC2N5W0raQ7JG0QEfOkogjZXr+H+4yVNLbJPAGgR9QmALmiPgHojcrNme21JE2U9JWI+KftSveLiPGSxpfb4JIuAFqK2gQgV9QnAL1V6WqNtldVUVwujojLysXzbQ8r1w+TtKA9KQJAfdQmALmiPgHoiypXa7Sk8yVNj4jTa1ZdKWm/8uf9JF3R+vQAoD5qE4BcUZ8A9FWVYY2jJH1O0t22p5XLjpF0iqRLbR8o6RFJn2xLhlghvfWtb03GjBo1qiX7mjZtWku2gxUOtWmQGTFiRDLm4osvbno/ixYtSsZUmYQagxr1CVmrMsR2pZXSA+yWL1/ecP3QoUOT23j88ceTMYNJsjmLiFsk9fQb3KW16QBANdQmALmiPgHoq0qfOQMAAAAAtBfNGQAAAABkgOYMAAAAADJAcwYAAAAAGaA5AwAAAIAM0JwBAAAAQAZozgAAAAAgA1UmoQZ67bnnnkvGpCYulKSVV145GTN37txKOQHI19Zbb52M+e53v5uMGTZsWNO53HzzzcmYn//8503vBwA6JSKSMVVep6W2M2bMmOQ2xo8fn4wZTDhzBgAAAAAZoDkDAAAAgAzQnAEAAABABmjOAAAAACADNGcAAAAAkAGaMwAAAADIAM0ZAAAAAGSA5gwAAAAAMsAk1GiLBx98MBlTZaLqVVddNRlz7733VsoJQGe89a1vTcacdNJJyZiPfexjTecyf/78ZMzEiROTMYsWLWo6FwBohyVLliRjnn322WTMWmutlYxJTVQ9duzY5DaYhPqVOHMGAAAAABmgOQMAAACADNCcAQAAAEAGaM4AAAAAIAM0ZwAAAACQAZozAAAAAMgAzRkAAAAAZIDmDAAAAAAywCTUWOGtvfbanU4BQANVJqXfZZddWrKvq666quH6cePGJbcxbdq0luQCAJ0wY8aMZMz3vve9ZMyJJ56YjImIhusnTpyY3AZeiTNnAAAAAJABmjMAAAAAyADNGQAAAABkgOYMAAAAADJAcwYAAAAAGaA5AwAAAIAM0JwBAAAAQAZozgAAAAAgA05NHtfSndn9tzNk76mnnkrGVJlg+qSTTkrGVJl4Fn0XEe50Ds2gNgED1p0RMbLTSTSD+gQMTD29dkqeObO9ke0bbE+3/XfbR5TLT7D9qO1p5ddurU4aAHpCbQKQK+oTgL5apULMUklfi4iptteWdKfta8t1Z0TED9qXHgD0iNoEIFfUJwB9kmzOImKepHnlz0/bni5peLsTA4BGqE0AckV9AtBXvbogiO1NJW0r6Y5y0eG277J9ge11e7jPWNtTbE9pLlUAqI/aBCBX1CcAvVG5ObO9lqSJkr4SEf+UdI6kzSWNUPHu0A/r3S8ixkfEyBX9A7kA8kRtApAr6hOA3qrUnNleVUVxuTgiLpOkiJgfEcsiYrmk8yTt0L40AeDVqE0AckV9AtAXVa7WaEnnS5oeEafXLB9WEzZG0j2tTw8A6qM2AcgV9QlAX1W5WuMoSZ+TdLftaeWyYyTta3uEpJA0S9IhbcgPA9g555yTjDn00EOTMQ8++GAr0sGKh9oEIFfUJwB9UuVqjbdIqjdJ2h9anw4AVENtApAr6hOAvurV1RoBAAAAAO1BcwYAAAAAGaA5AwAAAIAM0JwBAAAAQAZozgAAAAAgAzRnAAAAAJABmjMAAAAAyIAjov92ZvffzgD0m4ioN5/PCoPaBAxYd0bEyE4n0QzqEzAw9fTaiTNnAAAAAJABmjMAAAAAyADNGQAAAABkgOYMAAAAADJAcwYAAAAAGaA5AwAAAIAM0JwBAAAAQAZozgAAAAAgA6v08/4WSnq45vaQctmKgnzbi3zbq135btKGbfa37rVJ4vfbbuTbXuRbGIj1id9te5Fve5Fvocfa5IjOTTxve0pEjOxYAr1Evu1Fvu21ouXbaSva8SLf9iLf9lrR8u2kFe1YkW97kW97dSJfhjUCAAAAQAZozgAAAAAgA51uzsZ3eP+9Rb7tRb7ttaLl22kr2vEi3/Yi3/Za0fLtpBXtWJFve5Fve/V7vh39zBkAAAAAoNDpM2cAAAAAANGcAQAAAEAWOtac2f6I7ftsz7R9dKfyqMr2LNt3255me0qn8+nO9gW2F9i+p2bZeravtf1A+X3dTuZYq4d8T7D9aHmMp9nerZM51rK9ke0bbE+3/XfbR5TLszzGDfLN9hjngtrUWtSm9qI2DS7Up9aiPrUPtamJXDrxmTPbK0u6X9KHJM2R9FdJ+0bEvf2eTEW2Z0kaGRFZTpxneydJz0j674h4W7ns+5IWR8QpZRFfNyK+2ck8u/SQ7wmSnomIH3Qyt3psD5M0LCKm2l5b0p2S9pS0vzI8xg3y3VuZHuMcUJtaj9rUXtSmwYP61HrUp/ahNvVdp86c7SBpZkQ8FBEvSLpE0h4dymVAiIibJC3utngPSRPKnyeo+CPLQg/5Zisi5kXE1PLnpyVNlzRcmR7jBvmiMWpTi1Gb2ovaNKhQn1qM+tQ+1Ka+61RzNlzS7Jrbc5R/cQ5J19i+0/bYTidT0QYRMU8q/ugkrd/hfKo43PZd5an7LE51d2d7U0nbSrpDK8Ax7pavtAIc4w6iNvWP7J83dWT/vKE2DXjUp/6R/XOnjqyfO9Sm3ulUc+Y6y3K/pv+oiNhO0kclHVaeWkZrnSNpc0kjJM2T9MOOZlOH7bUkTZT0lYj4Z6fzSamTb/bHuMOoTagn++cNtWlQoD6hnqyfO9Sm3utUczZH0kY1t98kaW6HcqkkIuaW3xdImqRieEHu5pdjaLvG0i7ocD4NRcT8iFgWEcslnafMjrHtVVU8YS+OiMvKxdke43r55n6MM0Bt6h/ZPm/qyf15Q20aNKhP/SPb5049OT93qE1906nm7K+S3mJ7M9urSfqUpCs7lEuS7TXLDwfK9pqSPizpnsb3ysKVkvYrf95P0hUdzCWp68laGqOMjrFtSzpf0vSIOL1mVZbHuKd8cz7GmaA29Y8snzc9yfl5Q20aVKhP/SPL505Pcn3uUJuayKUTV2uUJBeXovyRpJUlXRARJ3UkkQpsv1nFOz6StIqkX+aWr+1fSRotaYik+ZKOl3S5pEslbSzpEUmfjIgsPkjaQ76jVZw2DkmzJB3SNS6502zvKOlmSXdLWl4uPkbFeOTsjnGDfPdVpsc4F9Sm1qI2tRe1aXChPrUW9al9qE1N5NKp5gwAAAAA8LKOTUINAAAAAHgZzRkAAAAAZIDmDAAAAAAyQHMGAAAAABmgOQMAAACADNCcAQAAAEAGaM4AAAAAIAP/H6WFZw0fGboPAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 1080x432 with 3 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import torch\n",
    "import torch.nn as nn\n",
    "from torch.optim import Optimizer\n",
    "from torch.utils.data import DataLoader\n",
    "from torchvision import datasets\n",
    "from torchvision.transforms import transforms\n",
    "import matplotlib.pyplot as plt\n",
    "from random import shuffle\n",
    "'''\n",
    "Step 1: (same step)\n",
    "'''\n",
    "# Use data with only 4 and 9 as labels: which is hardest to classify\n",
    "label_1, label_2 = 4, 9\n",
    "\n",
    "# MNIST training data\n",
    "train_set = datasets.MNIST(root='./mnist_data/', train=True, transform=transforms.ToTensor(), download=True)\n",
    "\n",
    "# Use data with two labels\n",
    "idx = (train_set.targets == label_1) + (train_set.targets == label_2)\n",
    "train_set.data = train_set.data[idx]\n",
    "train_set.targets = train_set.targets[idx]\n",
    "train_set.targets[train_set.targets == label_1] = -1\n",
    "train_set.targets[train_set.targets == label_2] = 1\n",
    "\n",
    "# MNIST testing data\n",
    "test_set = datasets.MNIST(root='./mnist_data/', train=False, transform=transforms.ToTensor())\n",
    "\n",
    "# Use data with two labels\n",
    "idx = (test_set.targets == label_1) + (test_set.targets == label_2)\n",
    "test_set.data = test_set.data[idx]\n",
    "test_set.targets = test_set.targets[idx]\n",
    "test_set.targets[test_set.targets == label_1] = -1\n",
    "test_set.targets[test_set.targets == label_2] = 1\n",
    "    \n",
    "\n",
    "'''\n",
    "Step 2: (same step)\n",
    "'''\n",
    "class LR(nn.Module) :\n",
    "    '''\n",
    "    Initialize model\n",
    "        input_dim : dimension of given input data\n",
    "    '''\n",
    "    # MNIST data is 28x28 images\n",
    "    def __init__(self, input_dim=28*28) :\n",
    "        super().__init__()\n",
    "        self.linear = nn.Linear(input_dim, 1, bias=False)\n",
    "\n",
    "    ''' forward given input x '''\n",
    "    def forward(self, x) :\n",
    "        #B = batchsize\n",
    "        # x input has dim [B,1,28,28]\n",
    "        # convert this to dim [B,784]\n",
    "        # after linear operation, output is dim [B,1]\n",
    "        return self.linear(x.float().view(-1, 28*28))\n",
    "\n",
    "'''\n",
    "Step 3: Create the model, specify loss function and optimizer. (LOOK HERE)\n",
    "'''\n",
    "model = LR()                                   # Define a Neural Network Model\n",
    "\n",
    "def logistic_loss(output, target):\n",
    "    #output has dim [B,1]\n",
    "    #target has dim [B]\n",
    "    #dimensions as is don't match!\n",
    "    #convert output dim to [B]\n",
    "    #conert target dim to [B]\n",
    "    #elementwise product (* is elementwise product in Python) \n",
    "    #after logsigmoid, dim is [B]\n",
    "    #after mean, dim is [1]\n",
    "    return torch.mean(-torch.nn.functional.logsigmoid(target.reshape(-1)*output.reshape(-1)))\n",
    "\n",
    "loss_function = logistic_loss                                                   # Specify loss function\n",
    "optimizer = torch.optim.SGD(model.parameters(), lr=255*1e-4)   # specify SGD with learning rate\n",
    "\n",
    "\n",
    "\n",
    "'''\n",
    "Step 4: Train model with SGD (LOOK HERE)\n",
    "'''\n",
    "train_loader = DataLoader(dataset=train_set, batch_size=64, shuffle=True)\n",
    "\n",
    "import time\n",
    "start = time.time()\n",
    "# Train the model (for 3 epochs)\n",
    "for epoch in range(3) :\n",
    "    for images, labels in train_loader :\n",
    "        # Clear previously computed gradient\n",
    "        optimizer.zero_grad()\n",
    "\n",
    "        # then compute gradient with forward and backward passes\n",
    "        train_loss = loss_function(model(images), labels.float())\n",
    "        train_loss.backward()\n",
    "\n",
    "        # perform SGD step (parameter update)\n",
    "        optimizer.step()\n",
    "end = time.time()\n",
    "print(f\"Time ellapsed in training is: {end - start}\")\n",
    "\n",
    "\n",
    "'''\n",
    "Step 5: (same step)\n",
    "'''\n",
    "test_loss, correct = 0, 0\n",
    "misclassified_ind = []\n",
    "correct_ind = []\n",
    "\n",
    "# Test data\n",
    "test_loader = DataLoader(dataset=test_set, batch_size=1, shuffle=False)\n",
    "# no need to shuffle test data\n",
    "\n",
    "# Evaluate accuracy using test data\n",
    "for ind, (image, label) in enumerate(test_loader) :\n",
    "\n",
    "    # Forward pass\n",
    "    output = model(image)\n",
    "\n",
    "    # Calculate cumulative loss\n",
    "    test_loss += loss_function(output, label.float()).item()\n",
    "\n",
    "    # Make a prediction\n",
    "    if output.item() * label.item() >= 0 : \n",
    "        correct += 1\n",
    "        correct_ind += [ind]\n",
    "    else:\n",
    "        misclassified_ind += [ind]\n",
    "\n",
    "# Print out the results\n",
    "print('[Test set] Average loss: {:.4f}, Accuracy: {}/{} ({:.2f}%)\\n'.format(\n",
    "        test_loss /len(test_loader), correct, len(test_loader),\n",
    "        100. * correct / len(test_loader)))\n",
    "\n",
    "'''\n",
    "Step 6: (same step)\n",
    "''' \n",
    "# Misclassified images\n",
    "shuffle(misclassified_ind)\n",
    "fig = plt.figure(1, figsize=(15, 6))\n",
    "fig.suptitle('Misclassified Figures', fontsize=16)\n",
    "\n",
    "for k in range(3) :\n",
    "    image = test_set.data[misclassified_ind[k]].cpu().numpy().astype('uint8')\n",
    "    ax = fig.add_subplot(1, 3, k+1)\n",
    "    true_label = test_set.targets[misclassified_ind[k]]\n",
    "\n",
    "    if true_label == -1 :\n",
    "        ax.set_title('True Label: {}\\nPrediction: {}'.format(label_1, label_2))\n",
    "    else :\n",
    "        ax.set_title('True Label: {}\\nPrediction: {}'.format(label_2, label_1))\n",
    "    plt.imshow(image, cmap='gray')\n",
    "plt.show()\n",
    "\n",
    "# Correctly classified images\n",
    "shuffle(correct_ind)\n",
    "fig = plt.figure(2, figsize=(15, 6))\n",
    "fig.suptitle('Correctly-classified Figures', fontsize=16)\n",
    "\n",
    "for k in range(3) :\n",
    "    image = test_set.data[correct_ind[k]].cpu().numpy().astype('uint8')\n",
    "    ax = fig.add_subplot(1, 3, k+1)\n",
    "    true_label = test_set.targets[correct_ind[k]]\n",
    "\n",
    "    if true_label == -1 :\n",
    "        ax.set_title('True Label: {}\\nPrediction: {}'.format(label_1, label_1))\n",
    "    else :\n",
    "        ax.set_title('True Label: {}\\nPrediction: {}'.format(label_2, label_2))\n",
    "    plt.imshow(image, cmap='gray')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "CIFAR10 (two classes) with logistic regression trained with random permutation cyclic batch SGD"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Files already downloaded and verified\n",
      "Time ellapsed in training is: 12.12409257888794\n",
      "[Test set] Average loss: 0.5001, Accuracy: 1536/2000 (76.80%)\n",
      "\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x432 with 3 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAA2cAAAFoCAYAAADTgoOZAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8rg+JYAAAACXBIWXMAAAsTAAALEwEAmpwYAABgsElEQVR4nO3deZxlV1nv/+9zTs1DV3X1PHenh4yEJIRACDKjMYoB7k+4KAiigtMVFL0IXiTqHcCLcPWnIiiTXmQSgSgIJEFIICFkoDN0hk53Uj2P1V1dXXPVOev+sXfLSaXWs6qrqqt2dz7v16teXV3P2fuss8/ea+91hvW1EIIAAAAAAPOrNN8NAAAAAAAwOAMAAACAQmBwBgAAAAAFwOAMAAAAAAqAwRkAAAAAFACDMwAAAAAoAAZnADAJM7vazD5vZvvNbNTMeszsJjN7o5mV57t9U2Vm683sBjM7b5Jat5l9cg7b8kkz656r+5tw3982s29P+NvVZnanmQ2YWTCzy2a7jfm2T2bW5O0Lk/zsjbUfAHDuqZvvBgBA0ZjZ2yV9UNK3JL1T0i5JCyX9uKQPS+qV9JV5at7pWi/pvZK+K+nx+W3KvPr1Sf72MUlDkl4haVDSdkl/IunP57Bdte6X9NYJfxvJ/52s/QCAcwyDMwCoYWYvUDYw+8sQwm9NKH/FzD4oqXUW7qcxhDAyyd/rJY2HEJLvtmDqQggP1f7fzEqSzpf0P0II36op7ZzThj3ZyRDC9ycrTGz/XIntpwCAM4OPNQLAk/2+pGOS/utkxRDCzhDC/af+b2ZXmdnNZtaffzzuFjO7qnaZ/KNye/OP0d1uZkOS/jT/yGEws183sz81s/3K3inpzJd7tZl938wGzazXzL5gZmsntsnMfsXM7jWzITM7bmbfMbPnmdmLJP17frObaj4q96JJ1vGsvHb9JLVT7Xc/zmlmG8zsH8zsoJmNmNnjZua+C2Vmf5S3/YSZHTWzb5nZcyfcps3M/n8z252v91C+zS+ouc3bzOzhmm1wt5m9qqb+Hx8LNLM3SaooOwe+J3/c3TWPtXvC/beY2fvN7In8I65PmNkf5AO82ttdbma3mdmwme0zs/dIMu/xT1XkY5lX1NzfHjN7d749Q81tTu1jb5qw7Ism7gv5fXzXzF5hZj80sxHl79jlz+2nzexI/hxsrd2++W22mNmXzOxw3qbd+T7LC8EAMEV0mACQywcfL5L05RDC8BRuf6mk70h6SNKbJAVlg7vvmNlzQwj31dy8Q9JnJX1A0ruVfZzulD+QdJekt0gqSxo2s19V9hHKT0j6Y0ntkm7I131pCOFk3oYPSHqHso/ovVdSVdJzJa2V9DVJvyHpryT9Vn4fytv7JCGEe8zsLmUfq/uPj2yaWaek10j60xBCxdkWGyT9QNnHA98r6TFJa5R9FNSzStKHJO1V9o7k6yXdamZX1gyCPyTpZ5Rtt8ckLZJ0jX40iP15SX+Wb6fbJDVLulRSV+Q+vyrp+co+6vkxSX+nH318cOLjqpP0DUkXKfvI4wPKtu978vW/I7/dYmUfgz0o6Y35+n5P2fMwZZMMZCqTvYua398tkvZL+gVJo5J+W9nHWGdii6S/UPZYH5d0zMzWSLpT0uH8Po5Ieq2kL5rZK0MIN+bL/quyj/z+mqSjyp7b68QLwQAwZQzOAOBHFiu7sN81xdv/obKL8JeGEHolycxuktStbIDy6prbtkl6fQihduCzPv/1kKRXnboIN7M2Se+X9IkQwptrbn+nsu9F/ZKk/2Nmm5RdLH8ohPA7Nff11ZplTg3EHo59ZK7GX0v6mJmtCyGc2ga/IKlB2QDG80fKtt0zQwj7a/7+KW+hEMIv17S1LOnrkrYpe4xvy0tXS/p0COFjNYt+qeb3qyXdH0L445q/fc25zyNmdjz/797EdnmdsoHcC0MIt+Z/u8XMJOm9Zvb+EMKpQUurpJ8IIezOH89Nmvq+JGUDzrEJf/sVTb7tf6fm/k5NGvINZfveTCyW9OMhhK2n/mBmH1P2DuALQwg9+Z+/kQ/a/ljSjflgcbOk62sGa5L0jzNsDwA8rfBqFgBM3wsk/eupgZkkhRD6JN0o6YUTbjuu7J2FyXx5wrsjV0taIOnTZlZ36kfZu0uP5PcrSS9T1o9/dKYPJPdZZe98/ErN394q6as1A4BybZssH6Uoe4fsXycMzJLM7GVm9u9m1qNsG40pe/fm/Jqb3SXpTfnH9q60p3688i5Jl+UffXyZmbWcThsSrlU2wLp9wnPxTUn1yt5Fk7Ln7PunBmaSFEIYkPQvp3Ff90l69oSfL0du+1xJd5x6XvL7G1LNwHyaumsHZrlrlQ12T0zYBt+Q9EwzWyCpR9k7be+z7GO2m2fYDgB4WmJwBgA/0qPs44brpnj7LkkHJvn7QWWzO9Y67HwscOI6lub/3qxssFL78wxlH+tTzb97NQvyj3J+QtIv5RfgP6bs43x/U3OznRPa88aatpxWO8zsCmUX/f3K3il7rrIByX2Smmpu+l8kfUTSm5UNxA6b2YdqBmF/r+yjdM9RNmA4Zmb/XPPO5EwsVbY/THwefpDXTz0HK5S9AzrRZH+L6Q8h3D3h52jktiuUfcxwJvc3mcn256XK3kGduA3+d15flL+48HJJd0v6X5K2W/adw1+bYXsA4GmFjzUCQC6EMJ5PuvBym9osdcckLZ/k78vz2pNW7931hP+f+ujYm5R9xG+ik/m/py7cV0l61Fn/6fiwso/MXS/pVco+JveNmvorJDXW/P+JmrasOs37+k/K3i17dQjhPz7OZ2YLlb2DJ0kKIfRLepekd5nZOkn/n6T3Kfue1TvzgcFHJH0kX/bHlX0H7XPKBmwz0aPsMb4mUu/O/z0gadkk9cn+NhsO6EeDeO/+Tn13smHC3xdpcpPtpz3Kvsv3/sgy+yUphPC4pF/I3019pqTflPTXZtYdQvi3yLIAgBoMzgDgyd4n6dvK3hWYOJX+qYkv2vPJKr4j6afMrL1mgo52ZQOYb8+gDbcrG4BtCiF439m6WdkEIG9RPjHFJE4NMJuncschhJ1m9k1lk1lcJumPQwjVmvoDkUW/KenVZrYihDDZuy+TaVE2a2Lt7IIvUTaJxhOTLZB/F+7P8klALpmkflzS58zsOXpqZth0fF3ZILI/hPCIc7s7JP2ema0JIeyRJDNrVbYvnAnfl/S7Zra65iOnzZJ+asLtDinbByZuq4m383xd2cc2t+UfnXTlg+WtZvY7yt4RvUQSgzMAmAIGZwBQI4Rwa35R+UEzu1DSJyXtVvYxxZdK+mVJP6csMPhPJP20sgki3q9skPFOZYOOP37q2qfchj4z+z1Jf2VmS5Rd2J5Q9s7UCyV9O4Twj/lA6kOSficfFN6obLBzlaRHQgifUzaByLikN5vZMWUX6o+eGkxG/LWyGRvHJH18is1+r7IL/tvN7H9K2pG399oQwusjy3xd0tslfdLMPqHsu2bvkbSv9kZmdkf+2B5Q9hHIFyp7Z+ZTef2jygazdyj7qN8WSW9QNmCcqU9L+kVlz/GfKfvIZYOkjcpmkHxlCGFQ2YySvy7pm2Z2g340W2NyMDNNH1T2Uc5vmNkf5ff3O/m//zHYDSEEM/ucso+qblf2DutPKZuVdKr+UNnHOG81s79U9m7hQmWDrvNCCG/OZy79c2XvVu5QNuvom5Tte9+aZJ0AgEkwOAOACUII/8fMfqBsBr4PKJvB7qSy79O8VfkkDyGE+y3LifofygYKpuwdjRdOmEZ/Om34iJntUXaB/3PKJp/YJ+lWSVtrbve7ZrZD2cDgjZIGlA0cv5nXe8zsN5UNGr+j7KL5xfLf2fuqsinxvxZCODjF9nbn71b9d2XfOWrP2/sVZ5lvmNlvKRtU/CdJDyr7btN/m3DTW5V9rPD3lZ23Hpf02yGEv8jr31M2gHqDssiC/ZL+r7IB44yEEMbM7Cfy+36LpA3KtvFOZdtpNL/dUTN7qbIByqeUfRTwb/L2/uFM2zFJu07d318o+87dqftbrGwb1nqbsu+Y35D/+3ll3+OLTVAz8b52m9mV+fL/U9KS/P4e1I9m4zyo7EWM35G0WtnHKR+Q9NMhhHum8xgB4OnIJolPAQA8jZnZy5UN7l4WQrhlvtuDqclnsbxX0tEQwkvnuz0AgNPHO2cAAEmSmW2UdJ6yj+jdy8Cs2MzsT5R9hHCXsgk+fllZ+PZ189kuAMD0MTgDAJzyHkmvV/a9qokfjUPxBGUfmVyZ/36/su/AMfkGAJyl+FgjAAAAABQAIdQAAAAAUAAMzgAAAACgABicAQAAAEABMDgDAAAAgAJgcAYAAAAABcDgDAAAAAAKgMEZAAAAABQAgzMAAAAAKAAGZwAAAABQAAzOAAAAAKAAGJwBAAAAQAEwOAMAAACAAmBwBgAAAAAFwOAMAAAAAAqAwRkAAAAAFACDMwAAAAAoAAZnAAAAAFAADM4AAAAAoAAYnAEAAABAATA4AwAAAIACYHAGAAAAAAXA4AwAAAAACoDBGQAAAAAUAIMzAAAAACgABmcAAAAAUAAMzgAAAACgABicAQAAAEABMDgDAAAAgAJgcAYAAAAABcDgDAAAAAAKgMEZAAAAABQAgzMAAAAAKAAGZwAAAABQAAzOAAAAAKAAGJwBAAAAQAEwOAMAAACAAmBwhmkxsxeZ2d65XnaSdb3JzL47G+sCcO4rSt8FALXom3AKg7OCMLP+mp+qmQ3V/P/nz+D9MrgBMG30XQCKiL4JZ6u6+W4AMiGEtlO/m1m3pF8OIdw88XZmVhdCGJ/LtgFADH3XmcV2A6aHvunMYrudObxzVnCn3qo2s3ea2UFJn5jsVRkzC2a2Kf+90cw+YGa7zeyQmf2NmTVP475/0cweNrOTZva4mb11ktu828yOmll37StRs9WGmsf2W3kbjprZ/zazSfddM/tzM9tjZn1mdo+Z/VhN7QYz+7yZ/X3+mLaZ2ZU19ZVm9kUzO2JmT5jZb02nvQDou/J1XWxmN5nZsXxd787/fpWZ3WFmvWZ2wMz+0swaJmyT3zCzxyQ9Np37BjA5+ib6pqJjcHZ2WC6pS9I6SW+Zwu3fL2mLpMskbZK0StIfTuN+D0v6aUkLJP2ipA+Z2RUT2rU4X/8bJX3UzM4/3TaY2V+b2V8n2vIqSVdKukLS9ZLeHLndXfl9dkn6R0lfMLOmmvrPSPqspE5JN0r6y7wNJUn/Ium+vK0vlfR2M/uJRLsAxD1t+y4za5d0s6SvS1qZr+uWvFyR9Nt5G65W1t/8+oRVvFLScyRdNIXHC+D00DfRNxVXCIGfgv1I6pb0svz3F0kaldRUU3+TpO9OWCYoO8BM0oCkjTW1qyU9Ebmvp6zLadeXJb2tpl3jklpr6p+X9J5UG/Jl957G9giSrq35/69LumUq7Zd0XNIz899vkHRzTe0iSUP578+RtHvCsu+S9In53h/44eds+aHvetJ9vk7SD6d427dL+tKEbfKS+X4++eHnXPmhb3rSfdI3FfyH75ydHY6EEIaneNslklok3WNmp/5mksqne6dm9pOS3qvslZpSvt4Ham5yPIQwUPP/XcpehZm1NtTYM8n9TNbmd0j65bwelL06tbjmJgdrfh+U1GRmdcpePVtpZr019bKk22bQZuDp7uncd62RtDPSvi2SPqjs0wAtyr7/fc+Em+2ZuByAWUPfNHn76JsKgI81nh3ChP8PKDtoJElmtrymdlTSkKSLQwid+U9HqPli7FSYWaOkL0r6gKRlIYROSV9T1hmcstDMWmv+v1bS/tlqwwRrJrmfiW3+MUnvlPQaSQvzNp+Y0OaYPcpegeqs+WkPIVw3gzYDT3dP575rj6SNkdqHJT0iaXMIYYGkd+up/dTEbQdg9tA3TY6+qQAYnJ2d7pN0sZldln+f6oZThRBCVdLfKvsc81JJMrNVie9OmZk11f5IapDUKOmIpPH81Z4fn2TZPzKzhnxg9NOSvjDNNqT8npktNLM1kt4m6XOT3KZd2UcCjkiqM7M/VPbO2VT8QFJf/gXhZjMrm9klZvbsGbQZwJM9nfquf5W03Mzenn+Rv93MnpPX2iX1Seo3swsk/do01g9g9tA3ZeibCoDB2VkohLBd0h8r+0LnY5Im5mm8U9IOSd83s778ducr7nnKXpGZ+PNbyj7vfFzSzymbQKPWwby2X9KnJf1qCOGR022DZTMO/Y3/qPUVZW+tb5X0VUkfm+Q235D0b5K2K/sowLCm+PZ7CKEi6RXKvmj7hLJXqf5OUsdUlgeQ9nTqu0IIJyW9XFm/cjB/vC/Oy7+bt+uksguuyV5sAjBH6Jvom4rEQuDdSRSbmQVlb7HvmO+2AAAAAGcK75wBAAAAQAEwOAMAAACAAuBjjQAAAABQALxzBgAAAAAFwODsacbMPmlm/z3//cfM7NFprudvzOw9s9u6abWj28xeNt/tAHDmnGv9FoBzB/0TZhuDswLKBxxDZtZvZofM7BNmNpMA50mFEG4LIXhTwZ5qz5vM7EnTyoYQfjWE8Cez3SYAZyf6LQBFRf+EswmDs+J6RZ78foWkZ0v6bxNvYGZ1c94qAIij35pFbCtgVtE/zSK21ZnD4KzgQgj7lAUrXyJlmV9m9htm9piy4ECZ2U+b2VYz6zWz283s0lPLm9nlZnavmZ00s89JaqqpvcjM9tb8f42Z/bOZHTGzHjP7SzO7UNLfSLo6f8WpN7/tf7yNn///V8xsh5kdM7MbzWxlTS2Y2a+a2WNmdtzM/srMbCqP38xuMLN/MrPP5Y/hXjN7ZuS2V5nZHfl2OJC3v2Gq7TCzN5vZw3ntG2a2biptBPBk9FtWNrN3m9nO/DHcY2Zr8tqfm9keM+vL//5jNcud6u/+r2Uhs286jc0OYAron+ifio7BWcHlB8x1kn5Y8+dXSnqOpIvM7ApJH5f0VkmLJH1E0o1m1pgPTL4s6R8kdUn6gqT/FLmfsqR/lbRL0npJqyR9NoTwsKRflXRHCKEthNA5ybIvkfS/JL1G0op8HZ+dcLOfVvZK1TPz2/1EvuzavPNb62yG6/O2d0n6R0lfNrP6SW5XkfTbkhZLulrSSyX9+hTb8UpJ75b0aklLJN0m6TNOmwBE0G/pdyS9Lt8GCyS9WdJgXrtL0mX6UX/2BTNrqln2ekn/JKlT0qcj6wcwTfRP9E+FF0Lgp2A/krol9UvqVXZA/rWk5rwWJL2k5rYflvQnE5Z/VNILJb1A0n7lkQl57XZJ/z3//UWS9ua/Xy3piKS6SdrzJknfnfC3T9as52OS/rSm1iZpTNL6mjY/v6b+eUm/P8VtcYOk79f8vyTpgKQfq9lWL4ss+3ZJX6r5f7Qdyl5F+6UJ9zMoad187w/88HM2/NBvPeWxXD/F2x6X9Mz89xsk3TrfzyU//JxrP/RPT3ks10/xtvRP8/DD50WL65UhhJsjtT01v6+T9EYz+y81f2uQtFLZwbsv5EdVbldknWsk7QohjE+jrSsl3XvqPyGEfjPrUfYqUXf+54M1tx9U1tFM1X883hBCNf/IwMqJNzKzLZI+KOlKSS2S6iTdM+FmsXask/TnZvZntavMH0NsmwF4MvqtH7Vr52QFM3uHpF/Wjx7rAmXv9p+yZ7LlAMwY/dOP2kX/VGB8rPHsVNsp7JH0P0IInTU/LSGEzyh7h2nVhM8hx97m3iNprU3+Bc9UUvl+ZZ2ZJMnMWpV9FGBf6oFM0ZqadZckrc7vc6IPS3pE0uYQwgJlH1Oc0mewlT3+t07Yjs0hhNtn2HYAmadTv7VH0saJf8y/v/FOZR9BWhiyjzOd0JP7qVS7Acw++if6p8JgcHb2+1tJv2pmz7FMq5n9lJm1S7pD0rik3zKzOjN7taSrIuv5gbJO5335OprM7Jq8dkjSaquZXGOCf5T0i2Z2mZk1Svqfku4MIXTP0mN8lpm9Ou/g3i5pRNL3J7ldu6Q+Sf1mdoGkXzuN+/gbSe8ys4slycw6zOxnZ9ZsABHner/1d5L+xMw254/vUjNbpKyPGlf+UScz+0Nlr0wDKA76J/qnecXg7CwXQrhb0q9I+ktlnw3eoXwGnRDCqLIJLt6U114r6Z8j66lIeoWkTZJ2S9qb316SviVpm6SDZnZ0kmVvkfQeSV9U1hFtlPSfp9L+/Iur/YkJQb6St+W4pDdIenUIYWyS2/2upJ+TdFJZ5/q5qbQhfwxfkvR+SZ+1bBaiByX95FSXBzB1T4N+64PKvgPyTWUvGH1MUrOkbyj7fut2ZR+FGhYfEwIKhf6J/mm+2ZM/NgsUi5ndIGlTCOH1890WAAAA4EzinTMAAAAAKAAGZwAAAABQAHysEQAAAAAKgHfOAAAAAKAAGJwBAAAAQAFMFow3ZWZ2raQ/l1SW9HchhPd5t1+8eHFYuzY+Y7r3EctSyR9HPjkP8PR5912pVNxlBwYG3PrY2GSzvmeq1aq7bFNTk1uvr6936+Pj8WB6r12SNDw87NZHRkaitdTjSm3TVN17vhsaYrEhmQUL/NiOtrY2t+7ti2dyP019BHmm9enau3evjh07NrMD8Aw4nf6pvqEhNLa0xNdVij+8ctl/zsulslsvOevO6tPf31qamt26178cPf6U2Z2fZGjI7x+qFb8PyPLkY8v6x3+o+vuy93ylpJadyXHkPWbpyUmv07nvcp2znzo1SUo8XRobiZ9LLPjrTm3TZN3pN1PbrO/4iaMhhCWJm82p07126mptDasWdkbrJWf7VxMbKLU7lxKZw9WR0WjNRv1rjJB4f2C0szNaqzT4l6+WeFzpo3h+vvIz02uIVL3k1EuJc1mq//LWLfnHebLvS9S9a87k9ei4Xx+vxPs+KX0MxRw5ckh9fScmfejTHpyZWVnSX0l6ubLshrvM7MYQwkOxZdauXatbb701uk5vsJC6YC6X/Qug1EnNG8T09/e7y95+++1u/ejR+EVOX1+fu+z555/v1lesWDHt+z5w4IC77KOPPurWd+3aFa2dPHnSXXamda8D8l4AkKRrr73WrV999dVuvb29PVprbvYvhuvqpv96SGrAmhpMpwbj0/WKV7zijKx3Jk63f2psadEzX/CC6PoamuID/tYF8UGdJC1ob3Xr7a3+PtPs3XeLv+5LNz/TrV9w4aZo7RNf+IS77EPbtrv1gV7/RauGhvjA8OQJv18cG/H35YaW+LqrSrwg1tDo1scr8YtRyb+IaKj3n+vUBcr4mH/fHQvjbW9f7L9oNTDob5eD3ceitbqK3/KGJv9FxHKTv80b6+JtL5X8fvEbn/9q/EQ1D6Zz7bRqYae+/Bu/Gl1nWyW+fQfq/Avq8aq//RoTl8XDO7qjtbpu/xpj3Pzruu5Xxc8tvWuWuss2JC64K4l+oOJc0M/0zQDvGWls9I+F1AvyqRenW5xjraXVP5el1t2UOo4b49c/qWv49PVP/M2C/v5Bd9njx/3zzfFjvW59zBk/eAPS//pf/0u0NpOPNV4laUcI4fE8lO+zkq6fwfoAYLbQPwEoIvomAK6ZDM5W6cnJ4Xvzvz2Jmb3FzO42s7u9d3EAYBYl+6favmls1H9HAgBmyWlfOx1LfHUCwLllJoOzyd6re8r73yGEj4YQrgwhXLl48eIZ3B0ATFmyf6rtm+oTH9cAgFly2tdOXa3+x5cBnFtmMjjbK2lNzf9XS9o/s+YAwKygfwJQRPRNAFwzGZzdJWmzmW0wswZJ/1nSjbPTLACYEfonAEVE3wTANe2p40II42b2m5K+oWw62I+HELZ5y/T19emWW26J1o8cORKtveQlL3Hbc+LECbfuzbAnScuXL4/WUrPEbNoUn/FM8mce9GaJlORuL0nq7e116/v3x1+QS83ud/DgQbfe6Uxzm5p5J2Vw0J9dx5v1cMeOHe6yn/3sZ916araka665JlpLPZ8p3nab6VT4qRmmztRU+/PhdPunEILG3e+dxWfuamn195dyYmpkb5YpSVKI37c3vbkkHek55Nbb9sfb3t+XiNIYSsxa6HebGh6MLx8S83+HxNTt3vIl8/umVARAak7nitMHhDp/3aXEVNVh1N+o1bH44z7W4886HMb97dJYjbetw4mhkKSqP8GcQmpadO915HLi+SqY6Vw7WV2DGpbFZyGuu3RjtNbY439freVg/LpLkiq7/BkXm9sXRWsN1/gzKnY/4s8IPVAfP9iax/19ZqzZ7xubyv5O2dYYn1m1MRFxlLr+qXrXCYnzdF1i3am2NTof4U9d+6QeVypWxkrxY7VUTkQAlP3nu+qcJxtG/ec6lbySGgN4131+PEF8/55RzlkI4WuSvjaTdQDAmUD/BKCI6JsAeGbysUYAAAAAwCxhcAYAAAAABcDgDAAAAAAKgMEZAAAAABQAgzMAAAAAKIAZzdZ4uo4fP67Pfe5z0bo3PfqSJUvcdd9zzz1uva2tza1feOGF0VpfX5+77GOPPebWd+/eHa0dOOBPU5uazr5anf40wg3OlKqSVF/vTz/qPV8bNmxwl01N45+a9t17TgYG/KmDU+v+whe+4Na9CIHLL7/cXTal5Ey7nprqPvW44AhBYSw+HW65IX4sDCdiHwbqE9OEm/+8Vkbj0xunpunfd6DbrQ8MH43WThzrdZcN4367S/KnXR4ecabiT0xX39TsT/nc1BKvDw/4fc/46Jh/54nnqzoW75NH5d93Ks0iDPvTg/efGIrW6lv8ldeP+fXFDfEpuruaW91le82PixhKPOEjI/HtVvZPY+eEcPKkRr/9nWh98LZbo7XGAX8a8LFh/3wZ+v3+rewci0ML/SfHnH1KkhasWRGtNbQucJdtTOwX9Yk+pLU5Hg/R4JwPpqQa398t0ad71wiSf12WWj51DZG63qwm8lPqnNWnzoPpxx0/3zQkojpaWuOxCZLU3u73b4ND8f7Je1Te9uadMwAAAAAoAAZnAAAAAFAADM4AAAAAoAAYnAEAAABAATA4AwAAAIACYHAGAAAAAAXA4AwAAAAACmBOc85GR0e1d+/eaP2iiy6K1sbG/OyZxkY/s2LhwoVu/atf/Wq01t3d7S47Ourk9STqqWVTuRLlsp8lNBMzWXcqny31fKWeby/37vDhw+6yqRy01PKf/OQno7WOjg532S1btrh1TyrnLFWHz0t4GR+LH6eNrX43OubleUkKwT/Gw3i83tSUuO9KPPdKkk6cjOdPpXJnLPiZOOVEZk7FyZUL8rdJc0s8g0iS6uvjrzv2DvvbJPGwp9Avxh93ZczPAUpFFSaifjQ+Hu83K4P+A2uo8zOnOjvjWaFm/vPVlgidKiX6rjEn3+3p0O1Vmxo0uHldtF4/Gt8IA4lsvJGqf64d8cKpJJWcp74x+Dts67pNbr1t1apozRJRY631/jVGQ6vfhzQ0xu+gZDN8X8PJOasmww4T1wHumcy9a4XE9WbqXJVqm7fdSqXEflb2616WWWU8kWmXyDkbTZzDzXlc484G97LbeOcMAAAAAAqAwRkAAAAAFACDMwAAAAAoAAZnAAAAAFAADM4AAAAAoAAYnAEAAABAATA4AwAAAIACmNOcs7a2Nl1zzTXR+vnnnx+tHT161F338ePH3Xp7e7tbNydgxsvUkqTxcT9H5NixY9HaTDLSJL/dklRXF3+Km5v9bIehIT8PqKkpnoszPDzsLlup+Hk/qSyhI0eORGtdXV3ust7zIUknT550648//ni09rGPfcxd9h3veIdbX7lypVv3pDLxZiK1n531glStxLefF+NUV+fvq9XEvp7qP+rK8WM49bQMDQ+69bHx+AoskTVWlwjdGk08Li8Tx8t/yZb1y2NOhpolXpMcH/VznyqJILR6J9MrFWHU0uzngY2OxnPppFQOmr+zjIbEftoQrwe/2Wps8HOGqmOJPE9nm6eez3NB3aLF6nrTL8brFu+DBhL7c92gf5w2JbL5yvXxPLDGJn/HaGhI1J2+LzQkro3Kfm5fg3NtJEl1dfH9aqbZesHpG4MXRJbdwq8mMtiCc7ykslIrVX9fSeWgefmTdXV+cF2p5J9nK07gXtXvfjQ25u8r7QsSj8vp37zLsrKzf5/7vRoAAAAAnAUYnAEAAABAATA4AwAAAIACYHAGAAAAAAXA4AwAAAAACoDBGQAAAAAUAIMzAAAAACiAOc05K5fLbgaVly+1e/dud93d3d1u/aGHHnLrXo7T5s2b3WVT2RBjY/GckZ6eHnfZkRE/16alpcWte3lj9U4+iZTOGvK2WUdHh7vsgQMH3LqXzyb5+SipbLiNGze69Xvuucetd3Z2Rmvbt293l03loL3lLW+J1lL5bSmpbDnv+T7Xc87MzN2n6priGSupvMDhfj8v0MtXO9W26H03+fc97j/lGnf2icF+PyNteNB/XCODftZhqMT7zYYGv1+rjCfyeJy8nfp6P9OmMuRn+aQyGKV4fXzc75vGK/591zf7/eKYd75IxM5VE8f4uMXPY6llLbEfps6hDeX4+ssN/nnsXGClsppb/azWmPYmv3+ptiT250TsVqkcv0HZyQqTJCsn6t6dm38spI7TupK/vH8+dBdNZ5Ul+xBn0USOWUrFOdYqiaxDLyNNkkJI9J3O4qXkNUbqvuPL1ydyGFta/PNoKiOy3sloGx2Nb5NSKb7eGQ3OzKxb0klJFUnjIYQrZ7I+AJgt9E8Aioi+CYBnNt45e3EI4egsrAcAZhv9E4Aiom8CMCm+cwYAAAAABTDTwVmQ9E0zu8fMJv2yjJm9xczuNrO7BwYGZnh3ADBlbv9U2zeNjfnfBQKAWXRa1049PbzBBjydzPRjjdeEEPab2VJJN5nZIyGEW2tvEEL4qKSPStLq1asT35IEgFnj9k+1fVPbgg76JgBz5bSunS677HL6J+BpZEbvnIUQ9uf/Hpb0JUlXzUajAGCm6J8AFBF9EwDPtN85M7NWSaUQwsn89x+X9MfeMr29vfrSl74Urb/4xS+O1hobG932vPnNb3brDz/8sFv/zGc+E621t/tT2KamffemMG9q8qd1Tj3u1H178QStra3usm1tbdO+71S7Vq9e7db37dvn1nt7e6O1RYsWucueOHHCraciBLxohNT0valIhw9/+MPR2s///M+7y65atcqtz8TZNpX+6fZPIQSNjsafV3MOw1Kdv228KeMlqa7kTwU+OhqfHn1w2O8f1i1c4dYXOP3P4sal7rJHW/0YkKN7/fiTYwPxqfbHElMXjyWmZi+V4sehM+txJjXLdeKsWak600kn4iyamvznc/WGxW79WI/Tt40n4kka/Q1TqYtHJwwPxo8dSSo1+9EIdQ3+Rm/qiLfdnGn2i2g6106lkqnBiQzwoghSu3uo9893laq/z1opPlV/yfy+L3VaKTnTxqfO06XEubhcnv5U+pVE/IlK/uP2ZtofG/Onox8d9SNOUkdDm3Pd15SIpahU/OM89X6P+3wnIgJCNfVe0vTfXK4mYqXq6vzHPeJu9MS+ErvPaS2VWSbpS/lFW52kfwwhfH0G6wOA2UL/BKCI6JsAuKY9OAshPC7pmbPYFgCYFfRPAIqIvglAClPpAwAAAEABMDgDAAAAgAJgcAYAAAAABcDgDAAAAAAKgMEZAAAAABTATKbSP22tra169rOfHa13dXVFawcPHnTX/YIXvMCtP+MZz3DrXp7Ytm3b3GW//e1vu/WWlnjGSyo/6qKLLnLrL3nJS9z6D3/4w2htx44d7rKptnn1lStXusum8ttSy996663R2mWXXeYum8o5Gx0ddeuehoYGtz6THLSPfOQj7rJveMMb3PratWvduvd8ejk654agUHXySJza+Eg8h0xK5F5JakhkAtZZPIOl1ZrdZdc2+7lYzcPxDKONl1zqLtv+Yn/dew8ccev9w/3RWvfubnfZR3f5GWoHjh+L1iqJ56txsb+vV/xDXArx42hp13J30a6l/spXrfe3+fKBeH10yH9cpUTeVf9A/Pkc7fNzgMrVRI5Qo98vNnfE8/gqTs7WucTL3ZpR/5x4ib7k7M+SZBbvv1Lnu5Kl6vH79vJjJSkkshD7h+O5fZKfEdvTE+9fJGn//gNuffeevfFlD/rL9g3E+01JGktcv6x3MmZf/crr3WU3blzv1ivjibxDZ3+oJvbhRAyazMnUS8a0hlRWsX+96h1/dXXxx1wqxRvGO2cAAAAAUAAMzgAAAACgABicAQAAAEABMDgDAAAAgAJgcAYAAAAABcDgDAAAAAAKgMEZAAAAABTAnOacLV++XO9617ui9Ztuuilau+2229x1pzIvvIwQSdqyZUu0lsrFuuqqq9z69u3bo7Xdu/28nvXr17v1VKaXlyvX3d3tLtvb2+vW77333mjtta99rbtsW1ubWz969KhbP3z4cLT2+te/3l02ld/m5ZtIfg7a8PCwu2zVy9KS1NPTE63t27fPXXbnzp1uPZVz5h1DqW129jOVy/E+orkpnrPUkMjyGUxsukVdy9z6Jes3RWvnLVvjLnu077hb37HniWhtNPHS3Xkn/OOkvCbebkl6/hXxPveFo34G0RO797j1O7beF63d+b073GVPnPSP0aZFfuZNR9eCaG2hk9clSV2L/Zyzxla/Pu7k7QTz84/K9f6O2laO53WqPpETNOgfI+OJUKpSXXy7jVf83KdzgZm5mWEz658T+VKJVZdK8ec+cbrT4KB/vhwdjedmjSTyClPnyx2PP+7WtzmZo9sffdRd9tCh+PWJJPUPxR/34mX++WDtxg1u3ZzsLEn68tf/LVrb+uD97rI3/MEfuPXNm85z64MD8cfd2OT3bV4mmCQFxXe21PEREll+DY1+TqOXc+aNPdyae48AAAAAgDnB4AwAAAAACoDBGQAAAAAUAIMzAAAAACgABmcAAAAAUAAMzgAAAACgAOZ0Kv1yuayOjo5o3ZvCvMmZyvrUuj2pKc69aVm9aTIl6YorrnDr9fXxaTiPHTvmLtvY6E/b/Bd/8Rdu/QUveEG0tmaNPw33ihUr3Pr4+Hi05j1mSWpo8KdNHRgYcOuLFi2K1lLT9KdiFVpbW926t/7U40rtx96+Njg46C47NhafdlhKTyc7k+fz7Bf8qXidafZT04Bv3hyfMl6Snn/lS9z6YmefqZjfN/37jofd+qGRvmjt8FF/OvuKMy2yJK1dtMqt7+uPr//iVf500s9J9E1r1q2P1kYT03ff+YPvufXWOv9cs3RhZ7Q2MOT3930n/OnBG0f8/uPY0fg5dGjYfz5LZf8YHx6I9z8Nwe8zVWl2y17fI0lli993R9k//s4V3jVO6hrFY+afD6sVf92HDsfjX3bt9qezH6366x4ajh8Pjz76iLts9xPxmBBJeuSRbX794fj6U+fatvZ4nIYkNbe2R2s/9iL/fLBw+RK33tLuH4ubLoifj/79m99wl33/hz7o1t/8hje69WNH4v3fBRdsdpfdtNmfpt9NhEi8DeXF6EhSfSJmxBSv19XFh1lMpQ8AAAAABcfgDAAAAAAKgMEZAAAAABQAgzMAAAAAKAAGZwAAAABQAAzOAAAAAKAAGJwBAAAAQAHMac5ZtVrV0FA8a2XXrl3R2sqVK911pzKcUjlno6Oj0VpXV5e77KFDh9y6l33l5XWl2iVJ9913n1v3MhZSjyu1zbZv3x6tffazn3WXnek2PXDgQLR22223ucsuXrzYracyY7wctNSyqee7vT2ef5J6PqrVeE6XJJ04cWLay69aFc+sqlTO/pwhM1NdvZM54vQvXe3+/vTy573Yra9Z7ueB3Xl//Bh/ZP9ed9mew0fdenDyeobkZ/nsOL7brW/acqFb7+3tj9YOdfg5QRs6/SyfNUvjOWk/fd217rJKZBidOLLHrXfUx9tWHU1lx/n3XQ2JPJ5qPE9sYMDPUBtwMqUkqRzi57GR8cT5N/G4E6dv1Ved4691Ti9j5oWZv428rr+UyjEb889Zd9691a1/89vfjdb2Jvqftev8rFU51z/9A/FMP0latMbvV89v8rfLIzvi1zeVYT+Xb2Qg3rdJ/rm8Ou5f8/X3+efxk4Px7EpJamiKH8dXPPvZ7rLfuekmt/6nH/Bz0F7ygniG28ZNG91lk7z9PBEDmIg5UymRc1bvXGe78WszyTkzs4+b2WEze7Dmb11mdpOZPZb/uzC1HgCYbfRPAIqIvgnAdE3lY42flDTxpcbfl3RLCGGzpFvy/wPAXPuk6J8AFM8nRd8EYBqSg7MQwq2Sjk348/WSPpX//ilJr5zdZgFAGv0TgCKibwIwXdOdEGRZCOGAJOX/Lo3d0MzeYmZ3m9ndPT0907w7AJiyKfVPtX3T2Jj/OX8AmAXTunY6csT/7haAc8sZn60xhPDREMKVIYQrU5MhAMBcqe2b6uvjX5IGgLlW2z8tWeJPOgTg3DLdwdkhM1shSfm/h2evSQAwI/RPAIqIvglA0nQHZzdKemP++xslfWV2mgMAM0b/BKCI6JsAJCUDQszsM5JeJGmxme2V9F5J75P0eTP7JUm7Jf3sVO5saGhIW7dujda3bdsWrb3sZS9z1z0+7udOpPLCvCyytrY2d9njx4+7dU/qo56NjY1uPZVtdfJkPAvkggsucJfdv3+/W/fywnbu3Okuu3evn8+UyuQ6ejT+Gfwvf/nL7rKp5zO1r3jZceVy2V122bJ4/pLkt62vz88vSeWNpTLYvMwNbz89dmzid97nzuz1T0EK8e3X1dIRrV255XJ3zSua4stKUvWhR9364ccfi9a6Dx50lx3rSeTtDMXrl9b7fc+qxia3fvCxh936oo54/9GdCKapH/VnIF/S2RmtLV3qf0TsysuvcOuP3uvngY1ZvF6q8z8+W6r4p+TGkl9vao8/J9VB/xxZTpxD60r10Vqfk18qScMDg249FTQ0PBY/z1Wc/Wg+zea10xTuK1orlfxz0l333OvWP/73/+jWe8fi/WZrIs905x4/K3F5Wzz3c8ECPwux3BTfXyWp57g/B0KjkwemEf8aYbh/wK2rLr6//+D733MXbemMbxNJamxtcetjznFervr97vKly916ueLngXV0dEZr9YnzzfFe//qntS2eL1lf5x8DqSA0L+dUkpQoRxdzlksOzkIIr4uUXjq95gDA7KB/AlBE9E0ApuuMTwgCAAAAAEhjcAYAAAAABcDgDAAAAAAKgMEZAAAAABQAgzMAAAAAKAAGZwAAAABQAMmp9GdTX1+fbr755mj9iSeeiNZS+VADA36uRKruZVcNJTJcvCwxSWpqimfPrF692l3Wy56SpIsvvtite7lbnU4WkCStXbvWrX/rW9+K1lpb45kTktTe7md1ePuC5D9fy5f7WRxepp0k/fCHP3TrXg7axo0b3WVTeXwjI/GMpJksK0ljY2PTXt7LWEvd79mgZKYWZ7/4yedcE69d82J33aNH/By4vpN+/3JVNZ7/Uk3kYu32YxA12tYcra3o8fvMlf3+835i3wG3vmpNPKPt6ICfzzayx3/c51+yKVorD/vtXpXItFm4xO9fdh/sjtYGB/x8pKEGP48nhGG3LicHra09/lxL0mCfn9c5OOjcd+Jl3vqyvyMOJHKj+k7G94cNG5b6d35OMDfLrFyO10ZG/X7/5ttvd+vDiXzMSy+9KFor1Sf6pye63XqTk/N68IDfv/Tu9LNSv/ONr7v10aH4/t6cyJ8tN/gZay3tXp6p3+7lq1b49ZUr3XpXZzwjcvkiPzOws93Plmtr9q/76urj59jDhw+7y/YcO+LWF3TE2+Zl8krSwoV+FqkTS5fxDpFpZqDxzhkAAAAAFACDMwAAAAAoAAZnAAAAAFAADM4AAAAAoAAYnAEAAABAATA4AwAAAIACmNOp9EdGRrRjx45o3ZsqfM2aNe66u7u73Xpqms7BwcFp1SSpWk3MV+1ITfuempJ+xQp/WtUTJ+LTsqam8e/q6nLrF1xwQbS2a9cud9nU4049X97+kGp3f78/TXdPT49b96biT0UbNCam4PWiE1JT4aem2k/VvfV70QW33nqru96zwZJFi/VrP/cL0frihx6N1nZ+/KPuuksj/vPW0RWf2liSNof4tm9NTEE+2O73H/UWn1a+foG/vwz2+dO6r2+MR4hI0vJqfLtc1rXIXbYpMZ30YH88nmDghB9t0Oz0mZLUNFZx6y2VeP+wSv7zcbLiz7t8YMyPAThcjT9nw4P+vmLy91NvPumRPj92of9koj6Q6JtCfJsPjSfa/TRgznzdPT3+/n7kRDwmRZIuuexSt/6Mi8+P1tpbW9xlt3d0uvWeg4eitUcPx6M4JOm27/nnpdETfgTS0qXx+KbV6/zr0QsT1wEXXRSPH1i7bp27bOdi//qmvS0+Tb8kNZXj0/xXx/zjsJKojyWuMSrunPN+ZMPYqL/uY0d7o7UDB/xrupbEefKKSy906/VOlIXZ9N4D450zAAAAACgABmcAAAAAUAAMzgAAAACgABicAQAAAEABMDgDAAAAgAJgcAYAAAAABcDgDAAAAAAKYE5zzsrlsjo6OqJ1L3erpcXPy9i6datbN/PzYw4ejGdmjI76+TCVip97U18fz5VoS2RSLFsWz9qQsuw4z6JF8bwgL3NOkp71rGe59S1btkRrqZyzpiY/A6m3t9ete3lizc3N7rKp+pIlS9y6lxe2cKGfWZV63F5mXmo/O3LkiFtP7StePpyXc1Yul931ng0aGxq0fu3aaH3/P30pWus7cNRdd7Xk5yD2lfztZ055JPj92qi3sKQlFm+bEy2VrTuRsVb/2ENuffhYPMuwft12d9nqhfG+R5LqyvF+tbPTP0Yb1sfzGyUpXP5Mtz565Hi0Vu3x95XRw3vd+uYG//k84eQkPnHggLvso8E/HxwZiudhDVf9nKCHj/s5Z0H+MVKpxPe1oSE/b+9cEEJwzw2lUrwfSJ1LG52+XZKWJM5pcvKnBkb9zMCutna33luK9xHnbfDzwIYGL3frWzZtcusXXhjPtlq/YYO77MJE1mqTk3daSpxPQyIPTMGvV0annwtYrvf3lVK93/ZKNX5SqVb9dteV/YzYSiV+fIwHv4947PF9bn3JIv8Y2LhupVufDt45AwAAAIACYHAGAAAAAAXA4AwAAAAACoDBGQAAAAAUAIMzAAAAACgABmcAAAAAUAAMzgAAAACgAOY058zM1OjkO1xxxRXR2tGjfj7MY4895tYXL17s1k+ciOdxpHLOBgcH3bqXbZXKrurri2fLSFLJybWRpKGhoWhtptvUy29LbRMvs0VKP24vW8vLIZP8dkvS0qVL3br32Lz9W0rn7Xlta2hocJdNZQF6+7gkdXZ2Rmve4/Iy0M4WoVrR6GA8i6laF39eehPP6SPDfv9xkfn74wrFlw8lf5+Q/P5l0KmHRO5MfSJPp3oinvclSf0DvdHa0MHd/n0//EO/3tQZrY13xrMfJck2xPPuJGnBFj/jqHldvN5+qZ+9JF3iVkuJY21ZiGcYLd3jZ/msf3S5W9//8F3R2q46P0fI6v08z76qn700MhavL+pI5HCdA8xMZee5Hx6KZ1geTeRfrl/lP++liv/cHDsSv46wRB+R6mM2b94YrbW2+sfKS1/yYrfe0uFnrJWda6uy+dddiVOCKs71T/IaIdEHlBLLBy/b0l1SGqv411b9/SfdentbPA+xq8vvl0dH/HPZ0GC8DzrR7/dPBw/3uPUnuv3z0cb1q5xqaqtOLvnOmZl93MwOm9mDNX+7wcz2mdnW/Oe6ad07AMwA/ROAIqJvAjBdU/lY4yclXTvJ3z8UQrgs//na7DYLAKbkk6J/AlA8nxR9E4BpSA7OQgi3Sjo2B20BgNNC/wSgiOibAEzXTCYE+U0zuz9/6z76oW8ze4uZ3W1md3vffwKAWZTsn2r7puMn/O84AsAsOe1rpyOJ740BOLdMd3D2YUkbJV0m6YCkP4vdMITw0RDClSGEK5ubm6d5dwAwZVPqn2r7poUdC+aweQCepqZ17bRkyZI5ah6AIpjW4CyEcCiEUAkhVCX9raSrZrdZADA99E8Aioi+CcBUTGsObDNbEUI4kP/3VZIe9G5fy5s6/vnPf3609sADD7jrPXTokFs/cOCAW+/o6IjWvGnbU8tK0pgzDfDAQHz67tSyUrpt3vpT076n2uZNd9/W5k+dnJoWPvUuq1dPTaWfihBITQ3vbZcdO3a4y1500UVu3ZtGNzXFbmtrfJpaSRoZiU+3LPn7g7fuVJzDXJtO/1Qdr2joaHzq95MWnw734eDvb/c0+FPljye64QXj8amP6+Qf/+VEDz/kJFqExHTQTZXE46r4cRly1h9G/emHSz3+lM2HS/G4i9u7t7vL1j14t1t/zpKVbn3x+nh90eXPdpftevEL3XopMf332H5nuvzD/jlyRaP/7nF7a/zdm6aSH9MxusQ/Hxwa8c81/ePxOInS3CYCzchMrp3MOWAOHoqf046d6HfXuyERHeFNKZ81LN6ukWH/nDMy5E9xvnJlfJr/4WH/azKp83hDnX8N0upcY5QSUUCp2dMrzvsiJfP79JRUTJGcc1kqZqgy7J/rTvT2uvXBk/F9cfsjfnRTKtqpoTEeWbVosR+PVFf1o59Sn6wZH4+Pa8zZ3t6OkuzVzOwzkl4kabGZ7ZX0XkkvMrPL8jV3S3praj0AMNvonwAUEX0TgOlKDs5CCK+b5M8fOwNtAYDTQv8EoIjomwBMV7E+jwQAAAAAT1MMzgAAAACgABicAQAAAEABMDgDAAAAgAJgcAYAAAAABTCnASGjo6Pas2dPtO7VbrvtNnfdqUyL7dv9bJtLLrkkWlu8eLG7bCqTa3Q0ntHiZYVJ6dyJVPaVV29v9zNzUnkZXttS+Wzbtm1z68uXx/NNJD8v75FHHnGXfeKJJ9z6iRN+Zo+Xo3b77be7y65fv96te8+Jtx9NRer5TOajnMMqlYr6++LZWcdDPI+kJ5Fj1rrI7z/298Xz1SSp50Q8K6jJ/OOs6masSE1O91HnBZFJGiv5mTejVX/5ciX+2mAq6Wegzt9Xvz8YP1ZuKfntajf/XFK3389JvObI4WhtaPtOd9mBXXvd+ooX+Dlo4842rwt+rlNDSzwnSJJKyzZEawt3+nFdlsik6hv2c872Ho9v8/6TfkbRuaJajR/LAwPx7bvl/Avc9Zbr/NfoKxX/OPfyMVPZmpXEdUJw+t2RET8jLWWw389/e+iB+DXKurXr3WV37vSvMVra47lZqe29efN5/rqb/fzakcH44963z8lJlLT9Mf86evujfn3/3vj69+/f7y7b2+ufJzectzFae9e73+0u++wrL3Prlsj6GxiM74sN9fFlvWOad84AAAAAoAAYnAEAAABAATA4AwAAAIACYHAGAAAAAAXA4AwAAAAACoDBGQAAAAAUAIMzAAAAACiAOc05CyG4uRXf/OY3o7Vjx465696yZYtb37Rpk1s/fDieTZPKl1q6dKlb93LQUjlmqZyQVDaVl//m5XVJ0sGDB926lzU2MODn1uzYscOte/uJJD3++OPRWiovY+HChTO673I5nsKU2k+PHDni1hsa4llEqey448f9HJCmJj/HyNuXvOw3bz84W5Tqymrs6ojWm1etjNZGT/g5S21d/v6mBj/Vq6cv/rwvSWTiVIL/3FSdRLE6/zBQnfy+Z9xSr/3F29aYyFgbTSShbR2L95vVTj93brTFz628L3GcXdIYb1tTn5+RNnLz1916ecR/vtuvfHa01jfoZ2pWju1y603e/lDxLyUayv5+2H88njEoSXsej2egjibOkeeCEKSK0z+XnHNSxclSkqS+E/5+MTDo92/eeaUynsgxS1y/NDgZkqnzdOraKpUntv/goWht7cYL3WV7Bvx9sr0rnkX2mc993l32imdd5tcvf6Zb/9qXvxit/fDee9xlexJ9X+pYLDvnhNTzpcQ5wdPW1ubWH09k3+7c6edTXv8zPxOtdXTEs2u9XZh3zgAAAACgABicAQAAAEABMDgDAAAAgAJgcAYAAAAABcDgDAAAAAAKgMEZAAAAABQAgzMAAAAAKIA5zTlramrS+eefH61/73vfi9Y2btzorjuV9/X85z/frd9zTzzf4dCheN6F5OeYSel8KU8qn6FU8sfXXkZbKicklbHm5X01NsZzPCRp7969bj31uBcsWBCtPe95z3OXTT0fe/bEM3UkP/8tlYnn5elJ0sqV8TytlNTzmXrcXo5ad3d3tJbaT84KpbJK7a3R8uKLL4jW6g/52S/1znolyZwsQkk6onj/0+ZH9Wg88fKbObkzdfL3p9aq3+6K+bk0oRTPvrJEdF5fIvPmRF28/9m4cbO/7KCfuXUokRe2vyPeL66v+vtC7wn/PLZr271uvXmkP1oLiZzEhcf8/bjq7KfDi+IZgZI0mNoXQuI8NhDvV6tjfp97LhgfH9ORI/GMvN27d0drJedYkKTh4WG3nsrX9K+9Ellkdf5+MeY8t1/5yo3usldddZVbf/azr3Trz3jGM6K1vXv9a4Sx0elnkq7fsN5dtqenx63v2+dfW+3YGc+YPZpYt5fDKkn1iXNZqMT3FUv2Ef6+1Oi0LZXp+y//8i9u/bHHHnPrz7riingxrI6WvIxY3jkDAAAAgAJgcAYAAAAABcDgDAAAAAAKgMEZAAAAABQAgzMAAAAAKAAGZwAAAABQAHM6lX5zc7MuvvjiaN2bsn7zZn/642XLliXv2+NNzZ6aKvzYsWNu3ZtWftWqVe6ynZ2dbj01vag3TW5q6tLUNvWWT0UbXH311W49tV2WLl0araWm4d+5c6db7+rqcuu7du2K1lL7ypEjR9x6KoLAU19f79ZTsQvec+a1OzVN7dkghKpGnWmbGxYvitY2PiM+zb4kHU9MC7//cX9/DGPxY3hhxT/+xxL3XVeKP+cNSixs8SnjJalU8vsXr9pQ8h/XyYp/nDU58QUdHX7/EOr8vuvQfv84evRo/Pla0uKfh4adaANJ2tkTn05dkpyZqrWs05/ufnTYn5J+tD6+8pMDfryALVrh1i+//HK3vnrN2mitMu5PW77tvm1u/WwwNDSk+++/L1r/h//7uWjtJ3/qZ9x1l0r+cZw6l3txHIlTjurK/iXonj3xaeEfeughd9n6Bv98uH7DBrdecvq3ctXf5y7YEJ8+XZL6+geitWdcdKG7rCX6xrrENr/ooouitQP79/sLp/hNk6Ua56hLTNPvXTulYoS6uha69UWL4ud/ServH4zWenvj0SwVp8NObikzW2Nm/25mD5vZNjN7W/73LjO7ycwey//1Hx0AzCL6JgBFRf8EYLqmMowdl/SOEMKFkp4r6TfM7CJJvy/plhDCZkm35P8HgLlC3wSgqOifAExLcnAWQjgQQrg3//2kpIclrZJ0vaRP5Tf7lKRXnqE2AsBT0DcBKCr6JwDTdVofADWz9ZIul3SnpGUhhANS1glJmvRLQGb2FjO728zuPnky/tlLAJiumfZNJ/r878wAwHTNuH86cWLO2gpg/k15cGZmbZK+KOntIYQpX8mEED4aQrgyhHBle3v7dNoIAFGz0Td1OBMCAcB0zUr/1OFP5gLg3DKlwZmZ1SvrXD4dQvjn/M+HzGxFXl8h6fCZaSIATI6+CUBR0T8BmI6pzNZokj4m6eEQwgdrSjdKemP++xslfWX2mwcAk6NvAlBU9E8ApmsqOWfXSHqDpAfMbGv+t3dLep+kz5vZL0naLelnUysyMzerYPXqeDbEkiVL3HVfeKGfDbFjxw637t13alkvS0ySdu/eHa2tW7fOXTb1uIeGhty6l7s1NuZndZTLfv5JQ0NDtJbK3Dp+/LhbHxiI54BI0t698fyTlpYWd9lUbsvgYDyzQvKz5VKZX6l1e3l7lYqfO3X4sP8CbOr5PnDgwLSWTWXtnUGz1jeFEDQyHD9W3MeYyAvs6vBz8x4f2+7Wj1fi+VMdDX5uVjURdNYU4m1vSRz/qvdPH6VE6E2ds01b6/z7Hkw8rnJLvG9avMzPrGnq9zNxduzwc+lOnoy3bbTR3yalsv+4lgR/uxwa6I/Whkf9vumO4fiyknTEOddcfFE8v1SSfvKFL3Xr5UT+2/h4fLtUq/42fd//er9bP4NmrX+qVoOGh7xsv/g22L9/n7vuFSv8TK6qF54nP3crOP2LlD6nedc3Xl6XJC3q8o/zVOboeufabEkiF6sz8TH5g0fi2bjHenrcZUtlf39P5ddecEE8l/OHW3/oLns0sc1C4lgsO5l4qeuI1PVoc0s829LLrJOka6+9zq17GcySNDISP0ef6I33q97+nxychRC+q3heqN/jAsAZQt8EoKjonwBM1/TjugEAAAAAs4bBGQAAAAAUAIMzAAAAACgABmcAAAAAUAAMzgAAAACgABicAQAAAEABTCXnbNaUy2W1t7dH616mVyofqr/fz2hJ5RR42RC9vb3usqlcrebmeIbLo48+6i6byvvy1i1JPU5mRmrdqQwSL8vMy0CT0tu0s7PTrXttS2WNpZ6vxYsXu/UNGzZEa6ncudQ29XLpGhsb3WVT+SYLF/rZLF5eX6l0br+OMz5e0YkTJ6J1r385dHC/u+6hcb/vOX7kqF+vxPfnUqO/r1vZzyhqK8efV/8okVoTeYFtiazDtrp4vTGxL1cTp67GxnhW2Zj57a5z2jUVYxZ/TswSmYCJrJ+6RG7Uod54fz9S3+Yuu30gnr0kScsXxPP6tqxc6y67cKGf9TdW8h/XmJNzFqKz1Z87yuWyOjri/femTZuitWPH/P7lgvP9vLAm51iS/PPGyKifAWuJY9E753nn4Wzd/n6xb5+f/3b+li3R2ui4nxn6L//2Nbd+7HD8OH3ta1/rLtvR0eHWe477x/FINX4srVrjH8epzLy2Zv+s0dYaz3/zxgZS+ppwyeL4+OGOO+50l/XyZSXpoYcecuurVsWzAjesj59PKk6/dm5fcQEAAADAWYLBGQAAAAAUAIMzAAAAACgABmcAAAAAUAAMzgAAAACgABicAQAAAEABMDgDAAAAgAKY05yzarWq0dHRaP3IkSPRWlOTn7WRykGrJjJ5Dh8+HK2dPHnSXTbl5S9/ebQ2NubnZdx+++1uPfW46uqm/xSHROaOJ/W4Wltb3Xoqt87Ld0vlYaSezx07drj1jRs3Rmupx+XlzknSzTffHK2ltmnq+VqzZo1b9/aVtWvj+SepTLuzQQhVN2PO67damvz8uUNP7Pbve8jPG2xYEN+nDifydipKZBUGp/9wHrMkJSLU1Fbxt8tCJ9dmUdnvt5rb/VyaJifTr7nJz+IZHvezChORXKoP8dc8m8b8xxX8p0ujibzB5W3xDKTly+JZPJLU3n6+W7/8ggujtdWb1rvLVhLbrJo41ZiXZWbn/mvMpVJJra3xnLqurniO3LaHH3bX3Z84Hy7qWuTWvXyq4WH/WBoZ9fs+73yaynhNXUPs3LnTrXvn08bE9ei2RC7W9++4K1r78et+yl22IZEldvyE/3yOjsQ77gsvuNhddmw4fo6UpNYm/znxtmkqA/b48eNufet9W6O1m265yV22Mu53QNWq34G95jWvi9aGh+KPa8jLlnXvEQAAAAAwJxicAQAAAEABMDgDAAAAgAJgcAYAAAAABcDgDAAAAAAKgMEZAAAAABTAnE6l39/fr+9973vR+vj4eLT24IMPuuv2ppKVpJYWf/rRoaH4lK+p6egvvDA+xbAkvfCFL4zWGhv96aY3b97s1nfv9qfp9qaN37Vrl7tsamrT3t7eaC017fuwM4WoJJn5U5d60+Smnq/U4zpx4oRb96bab2uLT3cspdvmTbV/9OhRd9lURID3fEnSihUrorXLL788WjsXptI3K6neeRxeQEJTsz+tctcCf58Y2ODHgAw6U9r3JZ7z8Yo/33290//s3bfXXfbQwXj0iSTtS8Sb7Dsef1wNZf91w4YB/xhtsfi55EWLl7nLPtH3uFsfG/Wnkx5xtmlfW3zacUmyit9vjpfKbn3tssXR2lBiCu6mZj8GpOqse3BRfAp/SVIi8qFk/uOqziDW5VzhnRJbW+PPrRcRIqWnlO/v96e796ZHb2iod5etb/DP8yMj8euExka/3122zD/OH3jgAbd+4MCBaG3Tpk3uss997tVufefj8b71wW1+9EFf4vmoJPr8vt74OePY0V532VTUx8EDh/wbWHxfWbDAj0dJ7cd79+6J1sbG/ViYpka/X77smc92673H+6K1nqPHojXvMfHOGQAAAAAUAIMzAAAAACgABmcAAAAAUAAMzgAAAACgABicAQAAAEABMDgDAAAAgAJgcAYAAAAABTCnOWctLS1uXtIjjzwSrTU3N7vrPnjwoFtPZTyNOllCqayx8847z617OSDe/UrSunXr3Pr555/v1r3sq+7ubnfZ48ePu/VyOZ5Nk3pcfX3xXAjJzzGT/By1wUS+UmpfOXTIz+rwHlvqcaeyV1pb41lDqYy0piY/92XLli1u3dum7e3xHJBS6ex/jcfM359LTnZVXSKTa0EiB22s0w+P8TKeTg74+/rKNavdetfSJdHakcOH3WX3dvsZi488st2tP7Fvf7Q2cNI//lP9w8nd3U67trnLjg77eTpDiYzGB8bimZl7Bv1cOku8XtpQ8evVw/G+q7/Ozwprb/WzyvZX4/vaJSU/W2ldIlsydX4vl+N5WY2Jfu9cYGaqq/Myw+J5Ye2JbL1q8J+7VatWuXUvs3Ro2O+fQvDz7+rr49mThxP9U+q6bPny5W5937590dr69evdZS+++GK3/hu/vihaqyv75/n+RLbl4UP+drnrB3dFa9+/I55DLEmD/X6+ZH29n2vX2BQ/j3rnX0mqVv39tKXFyWk0P8Nx8SL/uqxU8vP4Hnkknk3nXf97x07yqsrM1pjZv5vZw2a2zczelv/9BjPbZ2Zb85/rUusCgNlC3wSgqOifAEzXVN45G5f0jhDCvWbWLukeM7spr30ohPCBM9c8AIiibwJQVPRPAKYlOTgLIRyQdCD//aSZPSzJf58bAM4w+iYARUX/BGC6TuvLIma2XtLlku7M//SbZna/mX3czBZGlnmLmd1tZnenvicAANMx077pZOI7TgAwXTPtn1Lf/wZwbpny4MzM2iR9UdLbQwh9kj4saaOky5S9OvRnky0XQvhoCOHKEMKVbW1tM28xANSYjb6pvZ2+CcDsm43+aeHCScdvAM5RUxqcmVm9ss7l0yGEf5akEMKhEEIlhFCV9LeSrjpzzQSAp6JvAlBU9E8ApmMqszWapI9JejiE8MGav6+oudmrJD04+80DgMnRNwEoKvonANM1ldkar5H0BkkPmNnW/G/vlvQ6M7tMUpDULemtqRU1NDRo5cqV0fpdd8XzF5773Oe66250cogk6XnPe55bv/POO6O13bv9PJ/UxzW9/DYv10pKZ1ulsh+83InFixe7y6ZyQBoa4hkkIyN+VlAqD8zL3Eqtv5LI1PGea0l67LHH3LqXTZHK61m92s+d8p4vL7NOSmf5eXkbknTRRRdFa17eXurYO4NmrW+SzM1ZKTvPS50lsqcSuTWVsr+vh7HxaK2p1d/f1qz39zfv41IrlsSzeCRp03lr3PpFF/u5egeP9kZrx4/7OYiH9+/1130onmX4w60/cJcdOOlnM1UTfddgJd4nD8g/Bq3kZ/00JV5ObWmM72vL1/hZPlu2+Hmem7bEc6OWLux0l029ChwS57Fyg5cz5G/TeTRr/VMI0vh4vB/wznmVxLa96Zs3ufV9e+N5hJK0Zk28H2htbXGXbW7xc7G864Rjx465y3Z0+Ll9qUyurVu3Rmupc95AYn6F3p7eaG3vXr9vS12P7nXy2SSpp6cnWhsZiWc0SlJdIu+rZH6972S8J5hpjuvCzq74ss3+ftjY6K97eGTArZdL8X2pqSk+PjBne01ltsbvavKEw6+llgWAM4W+CUBR0T8BmK7Tmq0RAAAAAHBmMDgDAAAAgAJgcAYAAAAABcDgDAAAAAAKgMEZAAAAABTAVKbSnzUjIyPq7u6O1r3pYFPTaF544YXTbZYkadGi+LTRe/bscZfdv9+fatabojvVbm/6XCk9HaxXT01nn5qq1ptKPxUvkJqKNvW4vGnhOzs73WVTU+x6z5fkxx94U6NK0rZt29y6N7V5V1d8qlhJuuSSS9y6N1W+5E+X7+2HqSn6zwZmUqkUf60qOE9r1RLTo9f5+1ND2d9nxpyp+tsT+/KyZX4cRmND/DisjvmRFK1tfgxISyImZEFXPBoiBH+bjVcudesjg/Hp8Hfv9qeq3rljp7/uRL/p9V0NdfE+U5LqnH1QkloS0QlLlq+I1pau8KfSb2r2z7Ht7e3RWkM51V+7ZZUTcROTznmYq5wD/U/KyMiIduzc5dTj0+X3OJEVkvToow+79e4n/OPh/PPPd+uewSE/HmZkJB5bs9zZ1yVp08Z49IMkHT4Yj9uQpO/eemu0dlcijmfQ6X8kqb8vHhUyPBR/zFL6fFtKXL94sTAtLf6U8w31/nGampK+sTF+XehdT2bL+teMDc65rM6pZcv6/VdTk798Y2O8X25qjG/T+vvi98s7ZwAAAABQAAzOAAAAAKAAGJwBAAAAQAEwOAMAAACAAmBwBgAAAAAFwOAMAAAAAAqAwRkAAAAAFMCc5pyNj4/r6NGj0Xpvb2+0dujQIXfdF198sVt/4IEH3HqfkzuRytxasGCBW7/nnnuitb17/cydpUuXuvXFixe7dS9vI5WXMTY2Nu16c7Ofx7Nhwwa3nsrb8DKpUvltXpZYat2Sn4OWykg7mMhWee5znxutPetZz3KX9fLXpHRWYF1dvDtIbZNzgZdR5x0rlRDPGJKkusQ+kcqOkXOYLlmyxF20s6PTX7XzmBPxbQoVP4MxJFYwOBzvP5qa/JzEVCyWqvH7Xrduvbvo85xjUJJGxv3+Rc42LZf8fSF1lJX8SDyZk6NWSmy0sUS/6WxSVb2ipLGKfy4ZHfXr3tpLiYyic8H4eEVHjp6I1g8dimeS7u7e56675OQoZnV/pzuwL57zOjI64i47Oupneo2Px/eLgZN+ltjDax9x60/sfMKtHz0cv1atJPJnLXG+9DK7Ojr965NUHpiX95Xdd/w6oSlx3daUyBpL5ZzV1cWXr6/3H1cqa8xre2MiwzF1jZ+6rnPzbZ2ae83l3iMAAAAAYE4wOAMAAACAAmBwBgAAAAAFwOAMAAAAAAqAwRkAAAAAFACDMwAAAAAoAAZnAAAAAFAAc5pzNjQ0pAcffDBaHx6OZ154eV2SdPz4cbeeyhPzcrVSmVvPeMYz3LqXVfbQQw+5y3rbRJJOnIhnn0jSokWLorW2Nj9LKJWD5mXPeXl2kvT973/frXd0dLj1VatWRWupHLOU1PJeRonXLimdp+E9X6ltun37drfe1dU17bqXkTaeyHw5G4SQZQnFlMrxrJJq1c85C4kMqErwXyOrOsfhokX+c+rlqEjSuJPR5ma3SLKSvy+n7rvOyd1qSBwnjU1+PTiPKxFLp7oW/3Ennk7JicRJHSuVSnwflKSqs49KUqXqtD3R7lRWmd92f5ulsrJCIhfKa5mlHtg5oFKt6uTJk9H6yEg8T2zV6tXuujs7/XNt6pwVnP4vdQ0R5B+M3j43lsjGu+ceP9v2xPFet75saXy7NTUl8sASmVzeNvWuL6ZSb2r2r1cbGuP1VIZaXZ2/L6Qed2NjfP2px1WuOzNZY9IUzuGJ/di7by8jreTV3HsEAAAAAMwJBmcAAAAAUAAMzgAAAACgABicAQAAAEABMDgDAAAAgAJgcAYAAAAABcDgDAAAAAAKIJlzZmZNkm6V1Jjf/p9CCO81sy5Jn5O0XlK3pNeEENywsbq6Oi1evDha97LIvIwPSdq/f79bb29vd+teTkgq+yGVgbB27dpoLZU9tWPHDrfu5cZJUm9vb7SWymdbsGCBW/e2y4YNG9xld+7c6db37Nkz7fqKFSvcZcfG/HyUVN6Glw+X2mbr1q1z697jSu0rqcy7+++/3617z+eyZcuitf7+fne9Z8ps9k1mprKTu+VlV6VyzFIpTJWKn7HSUB9/Xjo7/Uy+ZD5LKZ7PYqnsqjr/tb36VCaOc5zVN/jLJjPYzMmPSbS7nHjCUtt03MluSjQ7C9xzpDLWvJw0b5tkdX+7eBlHqUy7UiLHzBJ173FVC5pzNpv9k0Jws5i8vvu8885zVz065mfveddGUuK5SfRt4+P+udg7V6f6zdHRUbe+fJl/314WWV0i+63Oya+S/OyrcuJYSmdA+hls9Y3xeupaN5U1lnrcVoo/Z9VExmMqA7LiHB+p/TB1lk7m9SXqzoLR0lTeORuR9JIQwjMlXSbpWjN7rqTfl3RLCGGzpFvy/wPAXKFvAlBU9E8ApiU5OAuZUy+N1+c/QdL1kj6V//1Tkl55JhoIAJOhbwJQVPRPAKZrSt85M7OymW2VdFjSTSGEOyUtCyEckKT836WRZd9iZneb2d1DQ0Oz1GwAmL2+qS/xsWkAOF2z1T8NDMzPR8cBzI8pDc5CCJUQwmWSVku6yswumeodhBA+GkK4MoRwZXOz/1lYADgds9U3LUh8JxUATtds9U+trfHvOQM495zWbI0hhF5J35Z0raRDZrZCkvJ/D8924wBgKuibABQV/ROA05EcnJnZEjPrzH9vlvQySY9IulHSG/ObvVHSV85QGwHgKeibABQV/ROA6UpOpS9phaRPWTYPb0nS50MI/2pmd0j6vJn9kqTdkn42taKOjg5dd9110bo3Hf7u3bvddaemCV+1apVbf+KJJ6K11atXu8sePuy/8NXU1BStDQ4OusumprFNfVTUm7I+1e7UtKreNLebNm1yl+3r63Prw8PDbv348fjMw6llU9M+p6akb21tnVa7pPSUq96U06nny5v6N7VuSVq0aFG05u1nqWnNz6BZ65tCCBqvxKeUHh2N15zZ6PO6f4PUVPztbd5HLv1lU9/zrW+M7zPlxNTq1UR9JHEcVsbjUyOnlq0r+/cdnO2SOv6tlDgtJp7wemf9iWbLEvuCtx9K0pgzLfrYmD8V9Xhiuuk6ZxrtusQxkJoGe2zUP8+lMwgKadb6p0x8G3hTs6f65/pG/zzf2OTX/SntE7ET46l6fH9O7VOpWApLzH7unS9TfXopMaW81wel+qfkNP2J5YPbf6UiStyyxip+PEFlNF4PzlT42Z37Ze88mlp36rrMi7GQ/GPMW7d3r8nBWQjhfkmXT/L3HkkvTS0PAGcCfROAoqJ/AjBdp/WdMwAAAADAmcHgDAAAAAAKgMEZAAAAABQAgzMAAAAAKAAGZwAAAABQAAzOAAAAAKAALDW//6zemdkRSbtq/rRY0tE5a8DUFbVdUnHbVtR2ScVtW1HbJZ1e29aFEJacycacaWdR3yQVt21FbZdU3LYVtV1Scdt2uu2if5o7RW2XVNy20a7TV9S2zVrfNKeDs6fcudndIYQr560BEUVtl1TcthW1XVJx21bUdknFbttcKPLjL2rbitouqbhtK2q7pOK2rajtmktF3QZFbZdU3LbRrtNX1LbNZrv4WCMAAAAAFACDMwAAAAAogPkenH10nu8/pqjtkorbtqK2Sypu24raLqnYbZsLRX78RW1bUdslFbdtRW2XVNy2FbVdc6mo26Co7ZKK2zbadfqK2rZZa9e8fucMAAAAAJCZ73fOAAAAAABicAYAAAAAhTAvgzMzu9bMHjWzHWb2+/PRhhgz6zazB8xsq5ndPY/t+LiZHTazB2v+1mVmN5nZY/m/CwvUthvMbF++3baa2XXz0K41ZvbvZvawmW0zs7flf5/X7ea0qwjbrMnMfmBm9+Vt+6P874XY1+ZDUfunovRNeVsK2T/RN81q2+Z1u9E3PVVR+yapOP1TUfsmp230T6ffriJsszPaP835d87MrCxpu6SXS9or6S5JrwshPDSnDYkws25JV4YQ5jXgzsxeIKlf0t+HEC7J//anko6FEN6Xd8wLQwjvLEjbbpDUH0L4wFy3p6ZdKyStCCHca2btku6R9EpJb9I8bjenXa/R/G8zk9QaQug3s3pJ35X0NkmvVgH2tblW5P6pKH1T3pZC9k/0TbPatnntn+ibnqzIfZNUnP6pqH2T07YbRP90uu0656+d5uOds6sk7QghPB5CGJX0WUnXz0M7Ci2EcKukYxP+fL2kT+W/f0rZTjrnIm2bdyGEAyGEe/PfT0p6WNIqzfN2c9o170KmP/9vff4TVJB9bR7QP01BUfsn+qZZbdu8om96CvqmKShq3yTRP81iu+bdme6f5mNwtkrSnpr/71VBNnYuSPqmmd1jZm+Z78ZMsCyEcEDKdlpJS+e5PRP9ppndn791P68fNTGz9ZIul3SnCrTdJrRLKsA2M7OymW2VdFjSTSGEQm2zOVbk/qnIfZNU7H1m3o+zU4raN0nF65/om56kyH2TVOz+qej7DP3T6bVLKsA2O5P903wMzmySvxVpPv9rQghXSPpJSb+Rvw2NtA9L2ijpMkkHJP3ZfDXEzNokfVHS20MIffPVjokmaVchtlkIoRJCuEzSaklXmdkl89GOgihy/0TfND2FOM6k4vZNUjH7J/qmJyly3yTRP03XvB9npxS1fypi3ySd2f5pPgZneyWtqfn/akn756Edkwoh7M//PSzpS8o+SlAUh/LP4J76LO7heW7PfwghHMp31Kqkv9U8bbf8s79flPTpEMI/53+e9+02WbuKss1OCSH0Svq2pGtVgG02TwrbPxW8b5IKus8U5Tgrat8Ua1tRtlvell7RNxW2b5IK3z8Vdp8pynFW1P6p6H1T3p5ezXL/NB+Ds7skbTazDWbWIOk/S7pxHtrxFGbWmn/pUGbWKunHJT3oLzWnbpT0xvz3N0r6yjy25UlO7Yy5V2ketlv+Bc2PSXo4hPDBmtK8brdYuwqyzZaYWWf+e7Okl0l6RAXe186wQvZPZ0HfJBV0nynIcVbIvslr23xvN/qmpyhk3ySdFf1TYfeZ+T7O8jYUsn8qat+Ut+HM9k8hhDn/kXSdslmHdkr6g/loQ6Rd50m6L//ZNp9tk/QZZW/Xjil7xeyXJC2SdIukx/J/uwrUtn+Q9ICk+/Odc8U8tOv5yj7mcb+krfnPdfO93Zx2FWGbXSrph3kbHpT0h/nfC7GvzcdPEfunIvVNeXsK2T/RN81q2+Z1u9E3TbpNCtc35e0qTP9U1L7JaRv90+m3qwjb7Iz2T3M+lT4AAAAA4KnmJYQaAAAAAPBkDM4AAAAAoAAYnAEAAABAATA4AwAAAIACYHAGAAAAAAXA4AwAAAAACoDBGQAAAAAUwP8DdpdqXErFr88AAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 1080x432 with 3 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import torch\n",
    "import torch.nn as nn\n",
    "from torch.optim import Optimizer\n",
    "from torch.utils.data import DataLoader\n",
    "from torchvision import datasets\n",
    "from torchvision.transforms import transforms\n",
    "import matplotlib.pyplot as plt\n",
    "from random import shuffle\n",
    "\n",
    "\n",
    "'''\n",
    "Step 1: Prepare dataset\n",
    "'''\n",
    "classes = ('plane', 'car', 'bird', 'cat','deer', 'dog', 'frog', 'horse', 'ship', 'truck')\n",
    "label_1 = classes.index('plane')\n",
    "label_2 = classes.index('car')\n",
    "\n",
    "train_set = datasets.CIFAR10(root='./cifar_data/', train=True, transform=transforms.ToTensor(), download=True)\n",
    "\n",
    "# Use data with two labels\n",
    "train_set.targets = torch.tensor(train_set.targets)\n",
    "idx = (train_set.targets == label_1) + (train_set.targets == label_2)\n",
    "train_set.data = train_set.data[idx]\n",
    "train_set.targets = train_set.targets[idx]\n",
    "train_set.targets[train_set.targets == label_1] = -1\n",
    "train_set.targets[train_set.targets == label_2] = 1\n",
    "\n",
    "\n",
    "test_set = datasets.CIFAR10(root='./cifar_data/', train=False, transform=transforms.ToTensor(), )\n",
    "\n",
    "# Use data with two labels\n",
    "test_set.targets = torch.tensor(test_set.targets)\n",
    "idx = (test_set.targets == label_1) + (test_set.targets == label_2)\n",
    "test_set.data = test_set.data[idx]\n",
    "test_set.targets = test_set.targets[idx]\n",
    "test_set.targets[test_set.targets == label_1] = -1\n",
    "test_set.targets[test_set.targets == label_2] = 1\n",
    "\n",
    "\n",
    "'''\n",
    "Step 2: Define the neural network class.\n",
    "'''\n",
    "class LR(nn.Module) :\n",
    "    '''\n",
    "    Initialize model\n",
    "        input_dim : dimension of given input data\n",
    "    '''\n",
    "    # CIFAR-10 data is 32*32 images with 3 RGB channels\n",
    "    def __init__(self, input_dim=3*32*32) :\n",
    "        super().__init__()\n",
    "        self.linear = nn.Linear(input_dim, 1, bias=False)\n",
    "        \n",
    "    ''' forward given input x '''\n",
    "    def forward(self, x) :\n",
    "        #reshape input into dim [B,3*32*32]\n",
    "        #output has dim [B,1]\n",
    "        x = self.linear(x.float().view(-1, 3*32*32))    # Flattens the given data(tensor)\n",
    "        return x\n",
    "    \n",
    "\n",
    "'''\n",
    "Step 3: Create the model, specify loss function and optimizer.\n",
    "'''\n",
    "model = LR()  # Define Neural Network Models \n",
    "\n",
    "def logistic_loss(output, target):\n",
    "    return torch.mean(-torch.nn.functional.logsigmoid(target.reshape(-1)*output.reshape(-1)))\n",
    "loss_function = logistic_loss                            # Specify loss function\n",
    "\n",
    "optimizer = torch.optim.SGD(model.parameters(), lr=1e-2)  # specify SGD with learning rate\n",
    "\n",
    "\n",
    "\n",
    "'''\n",
    "Step 4: Train model with SGD\n",
    "'''\n",
    "# Use DataLoader class\n",
    "train_loader = DataLoader(dataset=train_set, batch_size=1024, shuffle=True)\n",
    "import time\n",
    "start = time.time()\n",
    "# Train the model\n",
    "for epoch in range(10) :\n",
    "    for images, labels in train_loader :\n",
    "\n",
    "        # Clear previously computed gradient\n",
    "        optimizer.zero_grad()\n",
    "        # then compute gradient with forward and backward passes\n",
    "        train_loss = loss_function(model(images), labels.float())\n",
    "        train_loss.backward()\n",
    "\n",
    "        # perform SGD step (parameter update)\n",
    "        optimizer.step()\n",
    "end = time.time()\n",
    "print(f\"Time ellapsed in training is: {end - start}\")\n",
    "    \n",
    "\n",
    "'''\n",
    "Step 5: Test model (Evaluate the accuracy)\n",
    "'''\n",
    "test_loss, correct = 0, 0\n",
    "misclassified_ind = []\n",
    "correct_ind = []\n",
    "\n",
    "# Test data\n",
    "test_loader = DataLoader(dataset=test_set, batch_size=1, shuffle=False)\n",
    "\n",
    "# Evaluate accuracy using test data\n",
    "for ind, (image, label) in enumerate(test_loader) :\n",
    "\n",
    "    # Forward pass\n",
    "    output = model(image)\n",
    "    \n",
    "    # Calculate cumulative loss\n",
    "    test_loss += loss_function(output, label.float()).item()\n",
    "\n",
    "    # Make a prediction\n",
    "    if output.item() * label.item() >= 0 :\n",
    "        correct += 1\n",
    "        correct_ind += [ind]\n",
    "    else:\n",
    "        misclassified_ind += [ind]\n",
    "\n",
    "# Print out the results\n",
    "print('[Test set] Average loss: {:.4f}, Accuracy: {}/{} ({:.2f}%)\\n'.format(\n",
    "        test_loss /len(test_loader), correct, len(test_loader),\n",
    "        100. * correct / len(test_loader)))\n",
    "\n",
    "\n",
    "\n",
    "'''\n",
    "Step 6: Show some incorrectly classified images and some correctly classified ones\n",
    "''' \n",
    "# Misclassified images\n",
    "shuffle(misclassified_ind)\n",
    "fig = plt.figure(1, figsize=(15, 6))\n",
    "fig.suptitle('Misclassified Figures', fontsize=16)\n",
    "\n",
    "for k in range(3) :\n",
    "    image = test_set.data[misclassified_ind[k]].astype('uint8')\n",
    "    ax = fig.add_subplot(1, 3, k+1)\n",
    "    true_label = test_set.targets[misclassified_ind[k]]\n",
    "    \n",
    "    if true_label == -1 :\n",
    "        ax.set_title('True Label: {}\\nPrediction: {}'.format(classes[label_1], classes[label_2]))\n",
    "    else :\n",
    "        ax.set_title('True Label: {}\\nPrediction: {}'.format(classes[label_2], classes[label_1]))\n",
    "    plt.imshow(image)\n",
    "plt.show()\n",
    "\n",
    "# Correctly classified images\n",
    "shuffle(correct_ind)\n",
    "fig = plt.figure(2, figsize=(15, 6))\n",
    "fig.suptitle('Correctly-classified Figures', fontsize=16)\n",
    "\n",
    "for k in range(3) :\n",
    "    image = test_set.data[correct_ind[k]].astype('uint8')\n",
    "    ax = fig.add_subplot(1, 3, k+1)\n",
    "    true_label = test_set.targets[correct_ind[k]]\n",
    "\n",
    "    if true_label == -1 :\n",
    "        ax.set_title('True Label: {}\\nPrediction: {}'.format(classes[label_1], classes[label_1]))\n",
    "    else :\n",
    "        ax.set_title('True Label: {}\\nPrediction: {}'.format(classes[label_2], classes[label_2]))\n",
    "    plt.imshow(image)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "CIFAR10 with Multilayer perceptron"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Files already downloaded and verified\n",
      "Time ellapsed in training is: 213.10205554962158\n",
      "[Test set] Average loss: 0.3722, Accuracy: 1634/2000 (81.70%)\n",
      "\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAA2cAAAFoCAYAAADTgoOZAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8rg+JYAAAACXBIWXMAAAsTAAALEwEAmpwYAABUi0lEQVR4nO3dd5xkV3nn/+9TVZ2nZ3qSRiNNUECAkVBCiCAQmGzAS7DxmnVANjbGxj+Dw76w2TWWw+7Cro3Xv/UaWxgM2GBARK2NFwSWyQgkoYjSSJqoCd0TO3eFs3/UHSi1+jynp6u768zM5/169Wt6+ql769StW0/V6ao+XwshCAAAAADQWaVODwAAAAAAwOQMAAAAALLA5AwAAAAAMsDkDAAAAAAywOQMAAAAADLA5AwAAAAAMsDkDAA6wMyuMbNQfD1xjvrzW+ovavn5B81s+yKP5Zzieq5ZzP3O87qP387nt/ysZGb/08z2mlnDzD67FGMs9nftPMc319cvzTV+AAAWqtLpAQDAaW5U0s9J+v1ZP//5ojY46+d/LOkvlmFcy+U2Sc+S9P2Wn/2kpLdK+m1J35J0UNLe4nIPLfcAC78h6buzfvaQpGk9fvwAACwIkzMA6KxPS/pZM3tnCCFIkpn1SfoJSZ+SdE3rhUMInZqcLIkQwjFJ35714x8p/v2fIYRGy89nX2453RtCiF3/so/LzHpCCNPLfb0AgKXFxxoBoLP+XtJWSc9p+dlrJJXVnJw9xuyPNZpZxcz+2MweMrMpMxsxs6+b2XNmbffLZnabmU2a2WEz+4qZPTs2KDN7upl90sx2F9vcb2b/tZg4tl7upWb2DTM7amZjxeXe2VJ/opl9xswOFOPbaWbXm1mlqD/mY4HFbbu22Lx+/KOMsY81mtnzzOzLZjZqZuNm9gUzu2jWZcpm9ifFxyQnzOzfzOzC2G0/EZGPZc6+vn81syfP/hhl7COqxfj+bY7reK2Zvc/MhiXtb6n/spnd0XL/v9/M1sza51vN7N6W+/8WM3vNYhwDAMDi4Z0zAOisHZK+quZHG79W/OznJX1G0tg8tn+7pN+U9J8k3S5ppaQrJP3gxbmZ/amaHxF8v6Q/kNSQ9ExJWyR9M7LfLcX+PqjmxysvlPROSedJ+uliv+dJukHSJ9X8uOWMpAuKyxz3T5KOSPpVSSOSzpb0csV/OfgaNT9CeI2aHxeUmh8fHJh9QTN7haTPSfpnST/bcjy+ZmYXhxB2FT+7VtI7JL1H0hfVPD43RK4/pnR8QlkIIYR65LJ/WFzf/5D0JUmXL+D65vK/JP2LmudKrySZ2bvUvG//f0n/Uc3j+yeSLjKzZ4cQ6mb2M5L+TNIfqXmO9Um6WC3nCAAgD0zOAKDzPizpz8zsNyStlvQiST82z22fJemLIYTWv0P7P8e/MbMnqDl5+/MQwm+1XOafvZ2GEH7wrp2ZmaRvSDom6cNm9pYQwkE1Jx3dkn61+HiiJP1ry3br1JysvSqE0Do5+ahzvd8zsz3F9z/4uKCZPW5ypubf3n0lhPCqlsvdJOlhNScsbzOz1cXtvy6E8DvFxb5oZnVJ7/KOwSxfmPX/PZI2zb5QcX1vk/TXIYS3Fz++0cyqak6Q2vGdEMIvtVzXOWpOyP4whPBHLT9/QNLXJf24pM+qeY7c2XoZSZ9vcywAgCXAxxoBoPOul9Sj5ovpn5G0T9KX57ntdyW93Mz+i5k9x8y6Z9VfpGavv+5EBmRmK83s3WZ2fNGLqpofwTQ1J1xS8521qqSPmdlPmtkZs3ZzUM2J0ruKj95doEVS7Ot8SR8pPtpZKd7ZmlBzEZGri4s+Vc133T4xaxcfO8GrfIukp7d8vTxyuePXd/2sn3/yBK9vLp+Z9f8Xq3nfzj4GN6s5kT5+DL4r6VIz+19m9iIz61+EsQAAlgCTMwDosBDCqJrvcPycmh9p/MishTA8/1XNjyr+OzU/snbQzP6ueNdKktYW/+4+wWH9naQ3q/lxuRerOSF5S1HrLca9TdJL1Xwu+XtJ+8zsZjN7XlEPxba3SPpvkh4ws4fN7FdPcCxzOT4RfL+aE8TWr1fqh7d7Y/Hvfj3W7P+nPBBCuKXl687I5Y5f34E2r28ue2f9//gx2KbHH4OV+uEx+LCaHyt9hprvAB4ys08X77wBADLCxxoBIA8fVvOjhiVJr5/vRiGEqqR3S3q3mZ2p5sTkPZL6Jf17Nf/OS2r+LdL989mnmfVKepWka1s/LmlmT53j+m+SdJOZ9Ui6Ss2/a/pnMzsnhDASQnhY0s8XH428RNKvS/orM9seQviX+d7OORws/v09Nf+ua7aZ4t/jE5oNku5pqW9o47o9x6/vjHlc35SaHwudba1+ePtahVn/P36Zl0g6PMflD0o/mCT/jaS/KT52+RI1P2L5cTUnbACATDA5A4A83KjmR++OhBDuSV14LiGEfZL+1sxeLun4ioVfUnMBkDep+XdY89Gj5mqR1Vk/v8a57mlJ/2pmK9RcpONc/XBieHyCcLuZ/ZakNxbja2dydr+k7ZIuDCF4fzt2p6RxST+llr+HU7GoyRK4q7i+10m6qeXnr5vjsjskbTCzdSGEEUkys/MlPUnxhVpa3ajmfbslhHDjfAYXQjgs6eNm9gxJvzKfbQAAy4fJGQBkoFj5b97vmB1nZp+TdIeaYc6HJV0m6WVqvlOiEMJDZvbnkn7LzAbVXDWwLulKSfeFED4+x1iOmtm3Jf22me1Vc5L1i2q++9Z63W9W8++aPi9pl6R1ar6T9aiku83sYjUX7fi4mh+9K6s5wavpsROlExZCCGb2FkmfK/7O7hPFODdIeraknSGE94QQjhS3/z+Z2aiaqzU+Xc0J4qILIRw2s/8p6R3F9R1frfH49bV+XPV6NVe5/IiZvUc/PH4jmofivn23pL80sydJ+oqa78ZtVvPjpH8bQrjJzK5Tc8XNb6n5ccsnqvkR2i+2c1sBAIuPyRkAnNy+qua7Mm9R86OMOyX9d0n/5fgFQgi/Y2bbJP2apDeo+c7OnfJfnL9e0nsl/W9Jk2pOft6q5tL4x92h5qqS/03Nj/EdUnOVwJ8JIUya2b5iPL+l5sqGU2q+s/TKEMKtbd3q5u36vJldrWaMwN+quUT8PjVDoVsnndequZDJL6n5scqb1Vx8ZUHvUM7DHxTX90Y1YwFuVnNS+g1JR1vGv83MflLNpe8/K+kBNY/VO+Z7RSGEd5jZvWre/29R86OPu9RcUObB4mLfkPQLak7IVqk5ef6HYpwAgIxY85MmAABgqZjZ69Sc4F4dQvha6vIAgNMTkzMAABZR8fdcr1DzHbMpSU+T9Ltq/p3cswNPvACACD7WCADA4hpT82/x3qLmkvYH1HzX7PeYmAEAPLxzBgAAAAAZIIQaAAAAADLA5AwAAAAAMsDkDAAAAAAywOQMAAAAADLA5AwAAAAAMsDkDAAAAAAywOQMAAAAADLA5AwAAAAAMsDkDAAAAAAywOQMAAAAADLA5AwAAAAAMsDkDAAAAAAywOQMAAAAADLA5AwAAAAAMsDkDAAAAAAywOQMAAAAADLA5AwAAAAAMsDkDAAAAAAywOQMAAAAADLA5AwAAAAAMsDkDAAAAAAywOQMAAAAADLA5AwAAAAAMsDkDAAAAAAywOQMAAAAADLA5AwAAAAAMsDkDAAAAAAywOQMAAAAADLA5AwAAAAAMsDkDAAAAAAywOQMAAAAADLA5AwAAAAAMsDkDAAAAAAywOQMAAAAADLA5AwAAAAAMsDkDAAAAAAywOQMC2Jmzzez3cu97Rz7usbMvr4Y+wJw6suldwFAK3oTjmNylgkzG2v5apjZZMv/f2YJr5fJDYAFo3cByBG9CSerSqcHgKYQworj35vZdkm/FEL40uzLmVklhFBbzrEBQAy9a2lx3ICFoTctLY7b0uGds8wdf6vazN5uZvsk/d1cv5Uxs2BmTyi+7zGzPzWznWa238z+2sz6FnDdv2Bm95rZqJk9bGa/Msdl3mFmI2a2vfU3UYs1hpbb9hvFGEbM7H+Y2Zznrpn9hZntMrNjZnarmT23pXatmX3CzD5c3KZ7zOyKlvpZZvYpMxs2s0fM7DcWMl4A9K5iXxea2Y1mdqjY1zuKn19pZt8ysyNmttfM/tLMumcdk7eY2YOSHlzIdQOYG72J3pQ7JmcnhzMlrZG0VdKb5nH5d0t6oqRLJT1B0tmS3rmA6z0g6ZWSVkr6BUl/bmaXzxrXumL/b5B0nZk96UTHYGZ/ZWZ/lRjLayRdIelySa+S9IuRy323uM41kj4q6Xoz622p/ztJH5M0JOkGSX9ZjKEk6f9IuqMY6wslvc3MXpoYF4C407Z3mdmgpC9J+r+Szir29eWiXJf0m8UYnqVmv/m1Wbt4taRnSHrKPG4vgBNDb6I35SuEwFdmX5K2S3pR8f3zJc1I6m2pXyPp67O2CWo+wEzSuKTzW2rPkvRI5Loety9nXJ+V9NaWcdUkDbTUPyHp91NjKLbdfQLHI0h6Wcv/f03Sl+czfkmHJV1SfH+tpC+11J4iabL4/hmSds7a9vck/V2nzwe++DpZvuhdj7nO10v63jwv+zZJn5l1TF7Q6fuTL75OlS9602Ouk96U+Rd/c3ZyGA4hTM3zsusl9Uu61cyO/8wklU/0Ss3sxyT9gZq/qSkV+72r5SKHQwjjLf/foeZvYRZtDC12zXE9c435tyX9UlEPav52al3LRfa1fD8hqdfMKmr+9uwsMzvSUi9L+lobYwZOd6dz79os6aHI+J4o6T1qfhqgX82//7511sV2zd4OwKKhN809PnpTBvhY48khzPr/uJoPGkmSmZ3ZUhuRNCnpwhDCUPG1KrT8Yex8mFmPpE9J+lNJG0IIQ5I+r2YzOG61mQ20/H+LpEcXawyzbJ7jemaP+bmS3i7ppyStLsZ8dNaYY3ap+RuooZavwRDCy9sYM3C6O5171y5J50dq75V0n6QLQggrJb1Dj+9Ts48dgMVDb5obvSkDTM5OTndIutDMLi3+nura44UQQkPS+9T8HPMZkmRmZyf+dsrMrLf1S1K3pB5Jw5JqxW97XjLHtn9oZt3FxOiVkq5f4BhS/qOZrTazzZLeKunjc1xmUM2PBAxLqpjZO9V852w+viPpWPEHwn1mVjazi8zs6W2MGcBjnU69658knWlmbyv+kH/QzJ5R1AYlHZM0ZmZPlvSrC9g/gMVDb2qiN2WAydlJKITwgKQ/UvMPOh+UNDtP4+2Stkn6tpkdKy73JMU9W83fyMz++g01P+98WNJ/UHMBjVb7itqjkj4i6c0hhPtOdAzWXHHor/1brc+p+db67ZL+WdL757jMFyT9i6QH1PwowJTm+fZ7CKEu6cfV/EPbR9T8LdXfSlo1n+0BpJ1OvSuEMCrpxWr2lX3F7f3Rovw7xbhG1XzBNdcvmwAsE3oTvSknFgLvTiJvZhbUfIt9W6fHAgAAACwV3jkDAAAAgAwwOQMAAACADPCxRgAAAADIAO+cAQAAAEAGmJzhB8zsg2b2J8X3zzWz+xe4n782s99f3NEBOJWdav3HzLab2Ys6PQ4A7aE3YbkxOTvJFA+qSTMbM7P9ZvZ3ZtZOuPOcQghfCyF4y8QeH881ZvaYJWdDCG8OIfzxYo8JQGfRfwDkiN6EUwmTs5PTjxep8JdLerqk/zz7AmZWWfZRnaQ4VsAJof8AyBG9CacEJmcnsRDCHjVDly+SmnlgZvYWM3tQzVBBmdkrzex2MztiZt80s4uPb29ml5nZbWY2amYfl9TbUnu+me1u+f9mM/u0mQ2b2UEz+0sz+xFJfy3pWcVvq44Ul/3BRwCK//+ymW0zs0NmdoOZndVSC2b2ZjN70MwOm9n/NjObz+03s7KZvcPMHipuw61mtrmo/YWZ7TKzY8XPn9uy3bVm9kkz+4ciyPGaEzjsAET/aekjHy9uw21mdknkslea2beK47C3GH/3fMdhZr9oZvcWtS+Y2db5jBE4HdGb6E0nOyZnJzFrTkReLul7LT9+taRnSHqKmV0u6QOSfkXSWkl/I+kGM+spHnyflfT3ktZIul7ST0SupyzpnyTtkHSOpLMlfSyEcK+kN0v6VghhRQhhaI5tXyDpv0n6KUkbi318bNbFXqnmb7kuKS730mLbLUXD2BI5BL8l6fXFMVgp6RclTRS170q6tLhtH5V0vZn1tmz7KkmflDQk6SOR/QOIoP9IavaR6/XDPvNZM+ua43J1Sb8paZ2kZ0l6oaRfm+c4Xi3pHZJeK2m9pK9J+kdnTMBpjd4kid50cgsh8HUSfUnaLmlM0hE1H8x/JamvqAVJL2i57Hsl/fGs7e+X9DxJV0t6VEWcQlH7pqQ/Kb5/vqTdxffPkjQsqTLHeK6R9PVZP/tgy37eL+m/t9RWSKpKOqdlzM9pqX9C0u/O81jcL+lV87zsYUmXFN9fK+mrnb4v+eLrZPui/zzmeq6V9O2W/5ck7ZX03JZj9aLItm+T9JmW/0fHoeY7AG+cdT0TkrZ2+nzgi69cvuhNj7keetNJ/sVnb09Orw4hfClS29Xy/VZJbzCz/6/lZ92SzlLzAbcnFI+owo7IPjdL2hFCqC1grGdJuu34f0IIY2Z2UM3fMG0vfryv5fITajap+dgs6aG5Cmb225J+ST+8rSvV/M3Qcbvm2g5AEv3nh35we0MIjeLjTmfNvpCZPVHSeyRdIalfUkXSrbMuFhvHVkl/YWZ/1rrL4jbEjhlwOqI3/RC96STGxxpPPa0NZZek/xJCGGr56g8h/KOav0U5e9ZnmGNvke+StMXm/kPaVIr5o2o+gCVJZjag5scI9qRuyDzsknT+7B9a8+/L3q7m2++rQ/MjBUfVbBrHkb4OLL7Tqf9IzRdnx/ddkrSpuM7Z3ivpPkkXhBBWqvlRoHn9/Yiat/9XZh3HvhDCN9scO3A6oTfRm04aTM5Obe+T9GYze4Y1DZjZK8xsUNK3JNUk/YaZVczstZKujOznO2o2rHcV++g1s6uK2n5Jm1r/gHSWj0r6BTO71Mx6JP1XSTeHELYvwu37W0l/bGYXFLfvYjNbK2mwuG3Dkipm9k413zkDsHxO9f4jSU8zs9cWL87eJmla0rfnuNygpGOSxszsyZJ+9QSu468l/Z6ZXShJZrbKzF7X3rCB0xq96YfoTRlicnYKCyHcIumXJf2lmn9ztU3FyoQhhBk1/4jzmqL27yV9OrKfuqQfl/QESTsl7S4uL0n/KukeSfvMbGSObb8s6fclfUrNJna+pJ+ez/iLP3odc/7o9T1qfv75i2o2l/dL6pP0BTU/C/2Amm+tT4mPMQLL6jToP5L0uWIshyX9nKTXhhCqc1zudyT9B0mjar4w/Ph8xlDchs9Ierekj1lzddm7Jf3YfLcH8Fj0psegN2XIHvuxWgAAkGJm10p6QgjhZzs9FgA4jt508uOdMwAAAADIAJMzAAAAAMgAH2sEAAAAgAzwzhkAAAAAZIDJGQAAAABkYK7gvHkzs5dJ+gtJZUl/G0J4l3tllUro6o5FPkjNnLy5BTXcsaQ+npn89KbNN3NvATt3d5263uTAE3UsNvceyfljwomhBfcC8Vq9WlOjXs/uRDyR/rRu3bqwZevWWDnv+/VUlDybFn66ZXeingbSj542Hl+JTb/3ve+NhBDWL/wKFt+JvnZau25t2LLF6U/OQbAlPuPb6Ywn7WOx3YHzdJKVdl9l+6+d4lvv3LlDB0cOznmBBU/OzKws6X9LerGa2Q7fNbMbQgjfj23T1d2tc570xOg+u7t7o7Vafcodz8zMXPENP9Tw53ZSqRwtpe64EPydl0rOXZuYFDbaPG1Cw7tuf8+hjQlr6i3Zdp8wvMl4u39HGRJDqzv7byROtHLidpu37zZvV2ps9XotWguqR2uHd+1Z8JiWyon2py1bt+ob3/xGdH+1WvzYWOJxkqqnf7G0dM/kqbF5UuNq57i0e0yXalsszFKe46m+NjiwYseCd74EFvLaacuWrfrKV78S3ad3/Eqlpf2AVDv3XWps3mN1qfumd93tHtPTda2HTt3uds+V1HOG14O8bZ939fOitXbOsCslbQshPFyE9n1M0qva2B8ALBb6E4Ac0ZsAuNqZnJ0taVfL/3cXP3sMM3uTmd1iZrd4v30GgEWU7E+tvWlkeHhZBwfgtHXCr50Ojows2+AAdF47k7O53qt73HuDIYTrQghXhBCuqFTa+hM3AJivZH9q7U3r1mf1JykATl0n/Npp7bp1yzAsALloZ3K2W9Lmlv9vkvRoe8MBgEVBfwKQI3oTAFc7k7PvSrrAzM41s25JPy3phsUZFgC0hf4EIEf0JgCuBX/OMIRQM7Nfl/QFNZeD/UAI4R5vGzOppxyfD5bL8RUTq7XEcoupFRP9reUtXVhvpFZ68a+74Vx726uSpVa/Wdjq6M3r9laZTEmMK7UKZSdXkVPdvz/Nu79TqwI5cRGSJOdcayTOs5R2VizyVpHMcVngE+9Pwb39C12NaT46uaphO/tud+WtpV5FbsHaipw4ebVzf6a2Ta2o2MkVS5fbwl47mbq6urx9utvmKuf+5Mn5mC7l47jtlbCX8D7Jdd/+tvFaW38EFkL4vKTPt7MPAFgK9CcAOaI3AfBk+qtLAAAAADi9MDkDAAAAgAwwOQMAAACADDA5AwAAAIAMMDkDAAAAgAy0tVrjiTIzdVfiy+U3nNVJvWX2JSmUan49tdx9I759KbW0cqLecC6Qmh23e90WnIOaWg02ESHgbprYd2pp5SRvKds2l3V2l42XVCl552LiPEtGH8TrS76MrVO2Nu+uk5237HuqNy3lUvvt7ruTS5QvZTzBqaqTy2S3c92p+7OdWIVsIxkWUwiq1+tOuXNL6S/ledGOnJfSX8qxtfPaqpNL5XdyKfx245cWOvbgvMY+DboaAAAAAOSPyRkAAAAAZIDJGQAAAABkgMkZAAAAAGSAyRkAAAAAZIDJGQAAAABkgMkZAAAAAGRgeXPOFFSpxLM6aj0ro7XuciJXojbtlut1f/uak4OWzjBIjM3dd2JciciKUjJvw8nNSuSYNbzgK0nu7S61mwvRTo5Ie3kZydvtlENi20aIn//NHcS3ryfur9QRs0QGm3ueprY9yZlMJSevbClzhNrJYMk5D6ydbJh2M29O1vykTkrlhbVzTLk/2hNCULVadesxS50D105/aue8WOr7fSnzJZfSUj5OO/k4Tl7zEp5Lqdu90MxOcx6bvHMGAAAAABlgcgYAAAAAGWByBgAAAAAZYHIGAAAAABlgcgYAAAAAGWByBgAAAAAZYHIGAAAAABlY1pyzUsnU2xufD57xpEuitUMje9x9H9lx1K2PTdT8wTlZBPVUNlVqjutkIATzt200ErkTify3EOK3u5HIzWpHKr8tpb2sDr+eyn2pJTIvqg0vb8bPA2s0/PPQ29yCP+5Uxloq58ycK69753CbuXI5CJKCcxu9HJNURspS5wwtlXazX1K87XPOrupkFlA72XFLfd1LaSkz8U4KZip3KIexk+fzUuagtXPdp8U5twRO1szOlIVm4nm3+OR81QAAAAAApxgmZwAAAACQASZnAAAAAJABJmcAAAAAkAEmZwAAAACQASZnAAAAAJABJmcAAAAAkIFlzTmrVMo6Y81QtN6teJ7Y6vWb3H1P7rnLrY9bPJtK8rOxzE0jSOc8Nbxsh0T2VOKq1Ujkannlpc0xStyuxDFrLyfN37ZeT9xfTqaVlM4y86TOJXOOizmPj/lI3d/eeepuewpEvpj8PDKvttS5V53KeGp33+0cl3az4doZ+6mat9OupcwoSvfc0zvnzCQ358w7fjnnLC5tzlnqeXrh193uw+w0OGVRWOg53NbkzMy2SxqVVJdUCyFc0c7+AGCx0J8A5IjeBMCzGO+c/WgIYWQR9gMAi43+BCBH9CYAc8r3/W4AAAAAOI20OzkLkr5oZrea2ZvmuoCZvcnMbjGzW6an/b/7AoBF5Pan1t40PMIvsAEsmxN67TRCfwJOK+1+rPGqEMKjZnaGpBvN7L4QwldbLxBCuE7SdZK0Zs1K/gwSwHJx+1Nrb3ra055GbwKwXE7otdPll19OfwJOI229cxZCeLT494Ckz0i6cjEGBQDtoj8ByBG9CYBnwe+cmdmApFIIYbT4/iWS/sjbpq9S0lPW90Xr02v7o7Xdw6P+eJxlZiWp5JelxsKXCU7/SqudX3r5y6eHRmJsIT7/Ds5tljSPqbuzvHEyIiC1lH7qur1dp+7sxDGrJ8buDi4x8JC4P93YhcQxS9wub6n81HUnsiays5D+lOty3Uu5PLq/XHSqt+T7y/z2luDO93aldCpaIXW97dY9qWX4c7OQ3jSPfS6oJqVfnVgycsetJrZtp544p1L7dqv+BVKROCneyJf+bG4jFqfNwXl3SboFJM/UhV3xPCxl/4pp52ONGyR9pnjwVCR9NITwfxdlVADQHvoTgBzRmwC4Fjw5CyE8LOmSRRwLACwK+hOAHNGbAKSwlD4AAAAAZIDJGQAAAABkgMkZAAAAAGSAyRkAAAAAZIDJGQAAAABkoJ2l9E/YYF+3fvTiTdH6vv6zo7Wj+29x993dE89Pk6TS+LhfL8VzEEKb2Q6hFJ8DWyLvq1ZL5WIl8hucekhmcvllL1YiJPLZkvtOHHQ308v83zmk8t1SeWIlJzMjlbmTuu6Scz5YuydiKt9toTlGJ3Eu1HFBiYw55z4vOY/v1LadtpRjayf7pd3cmFxv11Jf91Jm9S3lvtvJu0o9/k4JZu7tbCfrLfVISd43zvNl+mGYeg2y8PMq9Tye5G3eZntJJZYuJfdxnMq+TZRTh8XdvN2sROfal7pjL7Q3eq/BT4OuBgAAAAD5Y3IGAAAAABlgcgYAAAAAGWByBgAAAAAZYHIGAAAAABlgcgYAAAAAGWByBgAAAAAZWNacs/6hQV3+yhdF69/6yn3R2uYt69x97x5e4dYPHzrs1rsVzwmZcWpNiRQFZwqcym4oqexfcyJIJDjXbcHPIjPzT49qPX7dPYlTq5HIdwuJ3Jaam2lRc7d1Iu0kSZZK63AzdxI5Z94dIkkWH3stcZqV64nztJS4v0P8XKtXZ+IbngI5ZyY/L6mdHKGlzJdaSu3mR3Uy3y3XLLKlHpd3zNu9P3LO6zvlhaBaLf7c4PWndnMYkzlobs7ZwvPrOm/pgs68rNRUOFz6mhOvCZ3bFUp59k1JaiRz0JzaQgZ0Ahaakeq91uSdMwAAAADIAJMzAAAAAMgAkzMAAAAAyACTMwAAAADIAJMzAAAAAMgAkzMAAAAAyMCyLqWvygrZhmdGyz3TN0drD33/AXfXkxNTbr1USiztXo5vX1fV3VaJ5e6t4Sxtmljjs1Lxx23mz6+Dc9X1ur+0egj+8uGlED8uITGu1LKo5cR6sd6K9fXEuOuJg16u+GOvO0samyWOWeI87O6J3/B6qdfd1j3PlF4O3juXavXpaG38yJi735OFtxyud+xSSwDnvIS5t8x2J5ejT93mpTzm7e673QiCdq57KW93Ozp5Lp0qFnpelcv+65PUft1l3+Uvpd/uY6Gt8ybVQ5JX7u26zaX0nSXUU3tOjzu1JL3zXJZKEWqztS30OVZKv5Pkvvxps/2k7m9v7As9V3jnDAAAAAAywOQMAAAAADLA5AwAAAAAMsDkDAAAAAAywOQMAAAAADLA5AwAAAAAMsDkDAAAAAAysKw5ZxaCuqfj2Vj9IZ4fVZ+YdPc9OTXj1kM5cVPH4tv3y89fmCn5OQYz7hy4vTyfri4/w6TbqVsqc6viX/c5Z54drR04GM/FkqThI0fc+kCvn+k1PhU/V0bHxt1tp+t+bl21Gt+3JDdHpGz+MduwfrVbHxyInw/jocvd9tio/xgY6PGPaaMRPy7Dh/z781Tg5ZEstNa8QKq8dNlVKV5/SeZ9JcZdKvu/+zMnAymZzZS4bi/LJznuxPGeqfn9I5UK5UnF8aRPtfgFQnrvbV03lpD5fcB7vCRzzBL11N3u1VNZqinebU71p9DWyBP9K5l75Y/NOy7WZiZgKdE7vTzT1BGrNxKvjRK8c63tPNA2tk2eS21kX7q3yykl3zkzsw+Y2QEzu7vlZ2vM7EYze7D413/FCQBLgP4EIEf0JgALNZ+PNX5Q0stm/ex3JX05hHCBpC8X/weA5fZB0Z8A5OeDojcBWIDk5CyE8FVJh2b9+FWSPlR8/yFJr17cYQFAGv0JQI7oTQAWaqELgmwIIeyVpOLfM2IXNLM3mdktZnbLyMjBBV4dAMzbvPpTa28aHhlZ1gECOC0t7LXTMP0JOJ0s+WqNIYTrQghXhBCuWLdu7VJfHQDMS2tvWr9uXaeHAwA/8JjXTuvpT8DpZKGTs/1mtlGSin8PLN6QAKAt9CcAOaI3AUha6OTsBklvKL5/g6TPLc5wAKBt9CcAOaI3AUhK5pyZ2T9Ker6kdWa2W9IfSHqXpE+Y2Rsl7ZT0uvlcWaMxqfHJu6P1eu9gtHbWlnPcfR/r8T+TPTnjZ9NM9PdHa12JHLMDRw771z02Gq3V636GmhqJ9IaGv33F4tlYq4bit1mSLnvSmW79P7ziedHa/7ruX9xt+yuJLI5uP9PLDsePaaPqZ6t0Vfrceu/ASrc+MR7P3GtU/fNsoGeVW3/elU+J1u7ctt3d9r5je936mav92zUwED/mM07O4NFETs5SWsz+lMoyWajUbhsl/wKldjK7Epk3XoRjqeI/PXSV/H2PTk+59UPjR6K1sUNH3W137N3t7/tA/A2JkpO1KUkXXBh/DErS5Zdd7tZLM04WUCofKfFck8p38/efOBETuy4lc9K8a07lCCWeB71tE5lSnbKYvclkbpaZ17uSOWaJc9IS953Xg1LXneKdN6kssWrNfx0wnXiunpmJ54bWElmoqWPa5fTWkpND1ty3W24r165S8bftTrwuKyeuu53ztJ3n59Sm7eacLTgv1CklJ2chhNdHSi9MbQsAS4n+BCBH9CYAC9W5X3kDAAAAAH6AyRkAAAAAZIDJGQAAAABkgMkZAAAAAGSAyRkAAAAAZIDJGQAAAABkILmU/mIK46Oavvlr0frYSDxX4pzzz3H3PXTe+W59KpF5MeME/lQb/rbDB/yMtcMj8Ry00bExd9tUhMvRI34ekGrT0dKaIT/vq5wI1Lj3wXiu1uaNG91tz0nk+dy9e59brzg5Id3d3e62Q2tXu/UzE2MPTvbcyPBBd9vq2DG3fvs990Rrh8fiWWOSNDXun0tHD/u5VH1d8eNScTJIUllbJ4OgoEYiMzAmlWmTyq0ppXKGyvHtZxJZPVOT8ce/JE3MxOs7Dw27225/cJtb37Nzl1vftS/eP7Y/stPddrTL78ndQwPRWqj5x6z6xRvc+s++8rVu/Sde+oporZF4Lukd8LMneyt+zlAyy8yRehS38yhPPUZCO78nTkT5nRLMz4HyspSS/SmRL1VLPF6OHDoUrR086D8fHj3qv36Zno73p1rdfyyVKj1uvbvHr/f3x3tIX7//2qnqZKRJ/uu+8Ylxf9tj8YxXSRoZSWT+TsZfR6xI9J8N69a49Quf4mdEnn32pmjNrL28Qu8xkHod3W7Omffawc1Ac/o175wBAAAAQAaYnAEAAABABpicAQAAAEAGmJwBAAAAQAaYnAEAAABABpicAQAAAEAGlnUp/fp0XWMPHYnW77ntkWjttvF73X0fDf4Sw/1DQ259YPWqaG1ojb/0+pOf7C8fumZofbxY9tcBrltineDEEp+T4/FlWafHjrjb1qbiEQCSNNy7Llpbe+EGd9vGqL/E7sj9/lLa1Xp8eeCxySl326N7/WX69+3b7db7++LL6E5P+cuxm/nLEk84t2tywl+et5I4lw6P+Uv0esu6jk/Hj2kjLGwJ+pyYLLmkdHTbxBrjqaiBas2v3/fIg9Hatu3xnilJvYkln3fsj5/rd+71973rIb++7Zu3ufXaVPx8Dv297rZXvfbH3Hrf1njPbXT79/PYA/7j/68+/AG3vnPnjmjtkosudrd92uWXufWtZyT6qrNUf3qp/NRy9/7W7Ugt937aC/5y3Ut59A4d9F8HfPQjH43Wbr/zDnfb1DPHisEV8W0T66OvWue87pK/pLwkPdVZFv5FL3qRu+0dd97p1r/z3e9Ga7t2+/1n5ar4a1VJOnjIf21Vd86jzZvOdrcdTUQjrP3Xf3Xrr/vJ10VrT7/iae62qeXsy6X465/UM3tq36nuV3det3mvq7yeyztnAAAAAJABJmcAAAAAkAEmZwAAAACQASZnAAAAAJABJmcAAAAAkAEmZwAAAACQASZnAAAAAJCBZc05K3X3q39rPMtgqBrPcDlzn5+vML3Hz64a2bffre95dG+0NjHh52ZVuvzD2Ncbz+xZf8aZ7rYbNm5x61u2+vV1Z26M1tY80c9n6+7xb9eMxTN1Zmb8DJFHH3nYrb9uy1Pd+oE9j0ZrRw/758qRo0fc+uHxY259YjR+20qJ4JZjx0bc+v59u6K17sTD1Up+2k13r595dWAkftwmp+P5bF7+zsnEy1ryclBSGU3TiePzL9/4hlv/2A2fjdYm63723cYNfn9phPj2Myv97MjQ1+3Wj476j6MVlXhfPOssP2/n2N5ht757T/xxNN3wj9lQ76Bbt17/uHzqn/9PtLZq7Vp328tKl7v1qbqfk9jlZR3W/fMwlfVj5vwul5iyJVcypwc14veNpX4HH/w7747b73br11//mWite7Df3fbZz7varVe64o+10bFRd9tV6+I5rJJ00yevd+tHDx6I1p7+tEvdbQ8f9J/n9+yK96e77vCz4Z7/whe49QufeqFbrzu5W+eee5677eSxMbf+/bv9c+VD//CRaG16atrd9slPfKJbX7tuTbRW6U48l7UXc+ZuH7zHl1PinTMAAAAAyACTMwAAAADIAJMzAAAAAMgAkzMAAAAAyACTMwAAAADIAJMzAAAAAMgAkzMAAAAAyMCy5pxNTE/ptkfuidZHy/GcglXrznD3fW7fCrdefeQRt77O2d7NKZA0msjzqVbjuTr7Evlr+/f7eRm333aLWw+VeO5N/0o/c2fjpk1u/ezN8Qy19av9fR8ZOerWQ49/zFeuiZ8rK4dWudueX/FP++GReL6JJPWtiOcgTTt5YJI0euywW9/hnKddiTyt+++/163v3+9nAa5wcqvWrR+K1kZH/PP/pGBSqRT/XZVX63KyeCRp2/btbv2zN/6LWx/aHM9/PMfJdpGkQ4/693mP8xSw/f6H3G33bY9n9UhSd8nJ3JK09oz10dqawZXutrUDR9z65rVD0dqGjVvdbVcm8pHWP+eFbn3VivhzyYbE89iBw4fc+ujYuFtfu3IoWhvs83MOeyv+eVx2+g8xZ0vLTCo7j6fQiActlcv+7+B3OxmvkvS5Gz7n1rdvjz9nXXCRn6XalciIvfvuu6K1Q04upyRtSmQ8Hnhku1t/9kUXRWthquZue97WJ7j1vU+Iv+7bvWOnu+3kmJ811rfFf93W5/SnipeTKKmvf8CtX3aZn9N48ze/Ga39zXXvc7d94zXXuPVnPusZ0VoqizjZvxKvvUpOBmRwQtK8vSbfOTOzD5jZATO7u+Vn15rZHjO7vfh6eWo/ALDY6E8AckRvArBQ8/lY4wclvWyOn/95COHS4uvzizssAJiXD4r+BCA/HxS9CcACJCdnIYSvSvI/awEAHUB/ApAjehOAhWpnQZBfN7M7i7fuV8cuZGZvMrNbzOyWo+OTbVwdAMxbsj+19qaRYf9vOwFgkZzwa6dh+hNwWlno5Oy9ks6XdKmkvZL+LHbBEMJ1IYQrQghXrBrw/yAZABbBvPpTa29at95fBAIAFsGCXjutpz8Bp5UFTc5CCPtDCPUQQkPS+yRdubjDAoCFoT8ByBG9CcB8LGgpfTPbGEI4vv7qayTd7V3+uJlaTTuH48uf3rpzW7RW7faXR1+1Lr4ssyQNrI1+eqBZXzEUrQ3v9z82vmK1/1utsrN0e6PuL8laq8WX4ZekvsTyyKEWX9q9Nukvy7znvtvd+v4Hvh+tHZn0l3tdvSa+PLgkNSrx5UclabCvP1qr9Pa6256ZWM5aE/7YQ19PtHYscUz7B+LL8EvS5nOfGK2de94Wd9uzEvVbvv4tt/6Qc39OzTjnUa3u7ne5LbQ/eULwz0fP3r3+UtWrV/vLxj/z+VdHaz3d8fgDSdo76EeIbL//vmjt4DZ/See15fjjQJIuf/Zz3Pq5T3lyvLblHHfb9ev8qI41Tr8fXOnHrnR3+bcrJBZerjtLJ1erftRGteo/HxydmHbrx0bj0QnBeQxL0oUX+Mt/Dw06y2iHhrstmpaiNzX3G6+lzrnv3uLH8TziLJUvSec94Zxora/Xj2fYvu0Btz5xKP56sX7Mj3B5cM9ut94Y9eN8qmOj0dqRI/5rwoEh/zXhs5797Ght6+az3W0r3f4x9ZbKl6Tegfhrp/4Bf6n8Ws1/nFviedKLGfnUJz7ubrs3EQU0MTkVrU07cVZS+nV0V5f/PGvOUvpyng+8xfSTkzMz+0dJz5e0zsx2S/oDSc83s0uLa90u6VdS+wGAxUZ/ApAjehOAhUpOzkIIr5/jx+9fgrEAwAmhPwHIEb0JwEK1s1ojAAAAAGCRMDkDAAAAgAwwOQMAAACADDA5AwAAAIAMMDkDAAAAgAwsKOdsoWZqde0aiWdT7BsZjtbO3OrnmPUO+NkOK9f6uVo9/fHtb/6Gnw+17kw/N2vDxrOitXrDz4jauWuHWz/zbD/bqjETz3cYXOFnWpyxyT+m/f3xvIz1k36uxIpE3le54edpHDl8OFo75mTpSdJ9jybyMqbi+SaSVFM8i2hoyD9Pt24536339cfzNkLDzxC58CmXuvVzz4lnqEnSZz/ziWjtwbsXJY4nX0Gq171zLv57rMlEftTEtP9YOGv9mW69ejh+PlblP076u/wW/yNPip8T5231e8v6RJbPxrP9vJ7B1fHsyoFeP2us5AU7SWo42XupyLqQ6D3m5tZIdSe7ckUig7F/TbynStJ01b/ukcMT0drd99/jbtvX62f9XHFh/FxJHDJZ4v5K3Slu1RaeQXiq8HIYt22L58dK6Ry0n/iJ1/rb1+PZe31OppYk9SfypczJ1Xr0wYfcbb92ffz5TJLOWLPGrR+9N577+YUPfcjd9rLnPN+tX/KMZ0ZrZ671x1VNZOOq5L/n0nAyCat1//VoT6Xs1iuJ+grn9c0VT3+6u20qg+3g4Xj2XCqndPVqPwe5N9G3e3riz1dl5/4ITmfjnTMAAAAAyACTMwAAAADIAJMzAAAAAMgAkzMAAAAAyACTMwAAAADIAJMzAAAAAMgAkzMAAAAAyMCy5pxV6w3tOzYZr4d4FsrBQ352Ve/KeGaOJI0ei+e/SFLPQHxcpUQW2f3f9zOgjjj5C8eOxPO6JGlyasqtd/X4OSETY2PR2qpV/jFblcgBmarF8zbq1UQWR9nPvVm50s+dOPsJT4jWzjI/a6PmZCBJUm08fswkaWo0ntV3yKlJ0oMPPuDWV64eitZuuvFGd1vJP6aDg362XJ9zLp119qZobfSAfw6fDMxMXV1d0XrdyZjbs3evu+9Kj5+RcvGFT3XrJedunZ6J9y1JUp+fM7RujfM4c/qxNI+swnL8eEpSzekfh4+Ou9v2dfs5aH093fFxJTK3ShU/E6dW83Ohdu7cE61NJ/r56DG/f+wfjmeBStKZ5/xItFZLPI8l2ofqzmHxMwKlRirHLBGUVnfq1dTtOiWYSqX489rBI/HXGN/+1rfdPfck8qM2bPAzYo+NHYnWBhLPOT3d8cepJNWdvNTxY/7z9Jouv0cMrPczSY9Oxl8z7rjjDnfbTRvi2baStOoFL4jWpiv+y/IdO/3s28NOBqzkZ36lXm+q5I9tIJFrV3Ze951z7rnutr1ORpok7Xk0/jy8cuVKd9tS2b9d9z/woFvfuHFjtHbOFi8vNH48eOcMAAAAADLA5AwAAAAAMsDkDAAAAAAywOQMAAAAADLA5AwAAAAAMsDkDAAAAAAywOQMAAAAADKwrDln9UbQocl4tk2jEZ8rHj7s55wdnfBzcULDz76adHK5Rob3u9uWu/x9jztZZoeGD7jbdvX4WR3HEsdlYix+XKYTx6zu5BBJ0ooVK6K1Xft2u9sOONtK0uZz4jlmkjQR4tk2PT1+bkspkdVRS2Re2KqhaG3tSj/X5ej2h9361nPPidbWONcrSdVpP39pZtLPMNk//Gi0tnL12mitnDheJwtz8q/qTpZSNfgZTWdvjmfESemMqEol3hertXgOkJTO5PIyb2pVPz/q6NFRt757VzzvS5IGnSzD4eGj7rbjE34e2OZNZ0ZrGzesc7fddv/33fqD99/nb79tW7T26KPxx5gkDe/f59Ynx/2e/R//8x9Ha1c+89nutiGRmTd8KP48VvdC0CRVq/556GXeSVLVyaacqp8OOWeSl4k05fT2RiIHbnLSv9+9jMdmPV4bGfEztwYT+VNWje987Vl+X135ih9z65PH/LGtGIv3mGoiK3HlBVvd+r07H4nWduxO9M1Edlw98XiYcHpI4qlMpYqfXdlwXpdJUtkJ7UwcUk1M+efpxNS0My5/399MZAHedNNNbv0lL31ptPbzP/sz0Zr3/Ms7ZwAAAACQASZnAAAAAJABJmcAAAAAkAEmZwAAAACQASZnAAAAAJABJmcAAAAAkIFlXQN7plrVzj3xZUJLpe54rcsfamPaXyY8BH/7KWcp/ZL89UXr0/5y1qPOMrelxDK3A73+UvrjznKvkjR+LL7cdSmxjO3IAX+Z/0d3xZfLn6pNuNtOjvrj7ion4glWxJeT7RmML9EtSV09vW690h0/DyWp5IzNEktCp6IRDjnHpavHX8a2J3GuDK1d49b7hvqjNW/Z9K4uf1wnC28l36mZ+DK9E4neMz7j94eJMf+x4i1PHBJLF3cl+ubIgeFobXh4xN324osvdevdicfRgeF4DMiRw/4xeeiRB936gw8/EK1t3rzR3fYTH/6gWx/eu9etNxrx54tSYr3oLic2QZLKieWmV/TFH4tf+uLn3W0fvP9et/7mN70lWqvW/LWqZxKPgUZi+e+ac0ynElEUp4rgvA6ZqcaP74pB/3m+Yf45V0sd3xDfvru7z910aI0fa9HlvH+wauWQu+2hY/7j/NCheO+TpMaxI/GisyS8JB01/znx1i98IVq77/t+lMems85261dddZVbn5qKP185K7tLkipOpIUk1Wr+67ZyOX5/lhK9r1r3j3m5FD/mO3bucre986673fpkIoborjvj2x9zXtN5sQfJd87MbLOZ3WRm95rZPWb21uLna8zsRjN7sPjXf0UMAIuI3gQgV/QnAAs1n4811iT9dgjhRyQ9U9JbzOwpkn5X0pdDCBdI+nLxfwBYLvQmALmiPwFYkOTkLISwN4RwW/H9qKR7JZ0t6VWSPlRc7EOSXr1EYwSAx6E3AcgV/QnAQp3QgiBmdo6kyyTdLGlDCGGv1GxCks6IbPMmM7vFzG6pJT6vCgAL0W5vGh72//4AABaK/gTgRMx7cmZmKyR9StLbQgj+ag4tQgjXhRCuCCFcUan4fywIACdqMXrT+vXrl26AAE5b9CcAJ2pekzMz61KzuXwkhPDp4sf7zWxjUd8oyV/aDwAWGb0JQK7oTwAWYj6rNZqk90u6N4TwnpbSDZLeUHz/BkmfW/zhAcDc6E0AckV/ArBQ88k5u0rSz0m6y8xuL372DknvkvQJM3ujpJ2SXpfaUQhBtXo8B6qrFM9pmknkR9UTWRwhkZFglfihKJf8OezMjP+3dBMTk27d33bcrTeCf7tmnAym0TF/2z4/DkybNm2K1ianxtxtG3U/9+bYgf1ufXQk/svGysAKd9uhNWvdeikR69LXE89uSSXuOJEwkqSR4X3RWi3xGOhO5I01av7o+vqcx59zfzWUCEdZOovWmyQ/5+zBhx6K1j71f/38qCdffLFbr5T8j3s3nCzEUsk/9qnsu6994yvR2ne+fbO77W/+1u+49TWJDKOJyXhf3Himn8nXP/Akt15txHPpgvn9evXQkFsfO3TIrZfL8ecS776UpODkeUnp56Iu53lspho/JpI0mcga23v4SLTWSDy/enk+UvO1gcfLjquHbHPOFrE/BfcYjE/F79tKt/9E3pPI/ayl7junNjAw4G470OvX5dzmciKfrS+xxsFAIp/WO6dLiZyzhx/Z7tcfiOc0rl895G67Z/dOt77jkbPc+tZzz4vWqk7eryT1J3JavRwzSSo5/auU2jaREelNAfbvjb+ukqTRo/6njYdWDbn1svMcPnYs/hq+4Qw6OTkLIXxd8dctL0xtDwBLgd4EIFf0JwALdUKrNQIAAAAAlgaTMwAAAADIAJMzAAAAAMgAkzMAAAAAyACTMwAAAADIAJMzAAAAAMjAfHLOFk2Q5MUoVK0ardUTOSiWyFnxcggkKTj5a6VEtoMlckB6VjjXnYiI6u/3M7tqiVyK1avieUGlHj8Xa2Yyfn9IUrUWzwnp6e13t50a8zNGvLweyc9eGaj493Vt7KhbHx/1s+X2jMfr1UTmTqXbP5cqTg5Io+7fH6kswMnEubJ2bTz/zcsh8rL0TibeQ/HosXgOyn0P3O/ud8UZ6936eU7ujCTVZ+IZRo1Eztm08xiVpHqIn1N9A93utg89dJ9bP/PM57r188+L5yQePXTE3XZoyD+mfYPxvjntHE9JGrnySre++6GH3XqtGj+m5bLfm3p64xmKUjqjMThZQM+66jnutqvO2ODW943E8936e/3nqVSOWTIp0emrJetYzuKyCcHPijt46GC0tj+RGdrj5HZKUlciP7OrK35Oh0SuX63q96cVK+LnVTmRNVaSf92WOG8aIb79sSN+juuju3e59fHR+PPJ+jWD7rZDK/3H2sGDw279ymc+I1rr6vJ7vvf6RJJKiey5upvjmHiN7yaRSpNObmYt0fN7uvzXm+vW+Zmd3mOk7jwHB6+vudcIAAAAAFgWTM4AAAAAIANMzgAAAAAgA0zOAAAAACADTM4AAAAAIANMzgAAAAAgA0zOAAAAACADy5pzJpmCMx/s74vnbYxPTLh7riemmYNDK916pTt+KEqJbJqp3XvcesnJdhhc6Wda9Pf7eWH79u5z64ODq6K1dWec4W5bTuS71WrxPJ+xI6PutmNjfk5IV7eft2FO3kY1keeVyjlaOejfJ729vdHaVCK35egx/7js3Re/P7ucDCNJWrVqyK0f3LfXrR/e6+ThODlF05Mnf87ZTL2uPUePROv1crw/rF3tZ08dGR5x60OXXO7WK05G48yM3xenp/3MvqGh1dHa+g1+7tWOXTvd+nPMf3o54mSZ/fmfvtvd9uffcI1bf+6PvCBaezTRM8+54AlufdMTznfrE2Px+2T1yiF324FEvx8f9/vHp6//VLTW5fQtSTp8zO/JL375q6O1csl/rkjlnJVT+Unl0/33yEENJzPsO9/5drT2hS/e6O45lXOWum+6nIyo3lRu3+oht77B6UHVGT/3c/+In/d13nl+vmR/f3zstbr/nHfkaDwTsLnv+ONl/frE88nReEaaJE1O+c8Ju3fH+7Y5z3OSGzfYtlLiPKsk8msrTu7dxKTfN+sN/1waWOH3TnPy3arOa0KvL57uHQ8AAAAAssDkDAAAAAAywOQMAAAAADLA5AwAAAAAMsDkDAAAAAAywOQMAAAAADKw7Evpq9zllONLYXYnllZvJOaZE4ml+AdKA9FarRZfwlaSLLHEubdc5syMv/R6at+p41Kvx8e+a/dud9s16+PLbEvSioEV0VpvYhn+QzV/uftyl3OeSKo4x2VqKrG0u39INTk56dZrzlL9Pb3+/bFh/Rq33ussF1sK/sDXrPX3vX/YX0K87kQjDPbFl/iecpawPVlMz8zooZ3xSIyxyfjjtOQsoytJOx5+yK8/8rBb7+uPP86s5C9RHuTHRvT1x/ve5k2b3W137fCX0j/gRTNI2nT2lmhtcLV/Lj/4yA5/3+ftitaOHvOXoj50+KhbX7vejxioVOLbl8p+f+jq8ZfS3/H977v1bdvi59LAoB8n8+KXvsytDzr9firRM1PPYyneMtvl8snff1JC8RUz6TznHTvmn899fX6PqFb9Zca9ZcRLieeGA8P+EuXbt8fP58kp/5w7eMhfzn58wu8DV199dbTWCP5rwtS++53XCV0V/2W5F10gSTNV/7hMz8TPlZL3+lySEvEoIfHiyo/U8I9pV8N/rjNnOfypxLmyYoXfd8fG/KX4vciricn43KPhZBPwzhkAAAAAZIDJGQAAAABkgMkZAAAAAGSAyRkAAAAAZIDJGQAAAABkgMkZAAAAAGSAyRkAAAAAZGBZc86CgmqN+Lr+Y2Pj0Vpfn5+HUQn+PNPLppKkiSPxXIpyIleiksg5qjoZL8PDw+62XYm8r3Vr17n1ipOZceToYXfbqXE/22FoaChaK1f8nLMBJzNHkmaczC1Jqjk5aSUnK0ySGvX4OShJ9ZK/vZe509frn6cTE/FzXJJWrhqM1oL545qs+Zl5W87b6tYnxuN5HL2V+Hl4eMTPdDkZ1GsNHTwYvx2jo/H7bcVgPCtMkg4Mx/PTJOnhB+5361vOPT9e7PJ7T1dvIgPKiY6pTvh5gSGRf3TvXXe49c1nbYrWXvPan3S3PXjI71233Pq9aG3HTj+f7a5bbnXruxMZa+Y8VvpXxB/fkrRy5Sq33jPoZ08+5dIrorXzL3iiu+2Tn3qJWz/o5L81nOd1qb0sUMnvuV1dfl88FYQgVWfiOVCbN8czA1PH9uDBg269mnjt5OlJ5J2Wy/5rK69eT+TPziT6065dfs7rMScP0as16/5rp7Wr4xmS9cTrk4lxP7Nr1HkdLUl7nfzJ3j7/uSz1us57vSn5faCROE/LTg+QpL274335jjvudLc94ww/uzIVjrt+/RnR2mGnb3rncPKdMzPbbGY3mdm9ZnaPmb21+Pm1ZrbHzG4vvl6e2hcALBZ6E4Bc0Z8ALNR83jmrSfrtEMJtZjYo6VYzu7Go/XkI4U+XbngAEEVvApAr+hOABUlOzkIIeyXtLb4fNbN7JZ291AMDAA+9CUCu6E8AFuqEFgQxs3MkXSbp5uJHv25md5rZB8xszg/Dm9mbzOwWM7sl9RlhAFiIdnvT0cTfXwLAQrXbnw6OjCzXUAFkYN6TMzNbIelTkt4WQjgm6b2Szpd0qZq/HfqzubYLIVwXQrgihHBFObFQAwCcqMXoTatW+QstAMBCLEZ/WrvOX/gLwKllXpMzM+tSs7l8JITwaUkKIewPIdRDCA1J75N05dINEwAej94EIFf0JwALMZ/VGk3S+yXdG0J4T8vPN7Zc7DWS7l784QHA3OhNAHJFfwKwUPNZrfEqST8n6S4zu7342Tskvd7MLlUzKWe7pF+ZzxWWnSgDL8eg6uRaSZL5EQlqhES2VTX+93D1xBS2UU7knDlj703kYk1NT/vX7QUVSaqV4rerq9u/+48dPOTW607+iSUyKfr7+vz6Cr8+ORnP5CpV/UyK3t5ut97T43/81pxcu0OH/cyY7kRunXeednUnMqsS52k5cd2r1sQ/2hfc+zoxrqWzaL2p3mhodDSe6zU9E7/96zec6e77tu9+263/w3vf59Zf8op/F62t3RjPV5GkyZqfiXN4/4ForSz/b4S7yv75dOMXv+jW77v7gWhtbDT++Jak/Yl8yAPD8cfh+KR/TEqJntrf3+/We3rjWUH9g36O2WonL0eSNiTyeFY7H3/rH1jpbtso+c8HNSd/KdUCqonMqVROWsX5k4hyuWP9J2XR+tPM9Ix27Hg0Wt9wxlnR2tCqNe6+H3hgm1v3MuYkqV6P94mLLrrI3fY5V13t1svl+P0+NeXnMB464v8dccnZtyRNTcbP2V07/ezKgyP+da9eORTf9mA8F0uSxsf92717V/w8kaSZary/rV7jf3y2u9vPOetJ1L0ctFSmb2+P/1p50jku1ZlEjqL5ve/MDf46PuvXxV8DjI3Gn2/qTt+bz2qNX9fcCWyfT20LAEuF3gQgV/QnAAt1Qqs1AgAAAACWBpMzAAAAAMgAkzMAAAAAyACTMwAAAADIAJMzAAAAAMjAfJbSXzS1ak3DB+JLIK9ZG19muNTjL7PpLW8uSdXajD84Z9XoxpS/DGd3v7/E5/j4eLS2YsUKd9vBwUG3Xuny78KGs/xxb7e/pPyo+UsUz8zEj2lq6eTR0WNuvXLYvz9Xr44v+15LxC6E4J9LtZo/9rkX4GpKRSP09PhLzU470QlV53g3h+XfX+XUY8TZf2g4j4FEjMXJoNEImpqO3/5SKX7OTE7659vwfn9Z5eqMv2T9rkd2x2u79rnbHjw84tanZuLn2+bNfkTAsSN+bMQdt93p12/9frQ22O/3ve5efzn7lauGorUtm89ztx1c4y93v2ptfN+StGoovnT5YGIp/f7++DL8ktTlLCkvSVaK1xuJx3+ly38+6HIiY8ptxmmE4DcRb0n1jJfSXzQzM1Xt2B5fvr1aiz/PP/nJ/nL2d911j1s/evSIWy85EQzeEuOStHatHx3hvY7werIkWSLqYzKxFP+e3fHeOjLs9/SpKf81xOHDo9FadZMfK1Eu+68hBgb8HtNVib9G6ar4++7v9iOOUkvpd3XH75PUUvmppfYHz3lCtHb2xs3utqm4iKHVQ269vy8eU1KrLey1E++cAQAAAEAGmJwBAAAAQAaYnAEAAABABpicAQAAAEAGmJwBAAAAQAaYnAEAAABABpicAQAAAEAGljXnLGV8YiJaK9f9jINUflR1xs+dqDtZQ+VEHlh92p/jdjvbNxp+pkXqdnk5ZpJUr8VzjCad4y1JU4kcEHNytVK5NfW6n+0kW/ipaU4OmSQ1Gv51Nxr+9iUnS6hS8cedymDzsuNSvPtDkpQ41+RkmTWc+yucAkFnjdDQxHT88VCverfR702XPeMqt156hn+/9fTEM79mZvzzaUN1q1uvO+dErTrpbps6na66+gVufc3qddHaQCLfsT+RD9nbF88L6+r283Qq/f79WU5kS3Y5+UuVkv9cUkllFZb8g+7lnJUSuU/etpJUcsfm94BUb0o9X/g5RIkT8RRQr9d1bHQsWp+YiNfWrd/g7vuKpz/TrR84cMCtdzv5eH2JvMKHHtru1t3+lMgj9baV0tm45mT3bd3qZyWuWbPerQ/0x3MaN5610d92wO99T73Yfxx3O3li3Ymcsp5E1lhX4vVPyckrTGWNpXqE+1o60X9SSYmp/lV3XjvVnOfohrMd75wBAAAAQAaYnAEAAABABpicAQAAAEAGmJwBAAAAQAaYnAEAAABABpicAQAAAEAGmJwBAAAAQAayyjnzsgS6EvkKqcyKVJ6Ym2KU2Heo+rlZq1atitZS+Qmp7Ida1c/68DK/pib9HLPkMXNyJ1LjTtX7++M5RZKfF5aIpUtnrCV0dcXHnsoxS2WvtKOaOBdCzb/d7rnkZL6cAjFnatQbmhgfj9brtfj91tcbz6yRpKdecrl/3akDGOLnW7mUaOHBP98qTu5MpZLoPTU/k6870bPL5fjYU8ckEXmj4PTV1HNFsHYyt6SKc5+kMhhT4XGNut9fvJ6cOmbJLCCn7uX1zGPX8+DdrlOgASUEBVXr8f7sHf7Va+J5gpJ09fN+1K3XE88b3p1b8p43NI+sMa/W5muMstP7mvX49u2ect51ez1ZksoVv55K7fIex8nXo230CCnRn9wtJWvjoCcz0hL11HUvRQfinTMAAAAAyACTMwAAAADIAJMzAAAAAMgAkzMAAAAAyACTMwAAAADIAJMzAAAAAMgAkzMAAAAAyEAy58zMeiV9VVJPcflPhhD+wMzWSPq4pHMkbZf0UyGEw/6+/OyJSiIXxzM95Wd2TU9Pu/WS4tkRqewqK/m5E9YVr6eyNlL5CeXEdXu5ONNTk/62icydSiV++vT29rrb9vX1ufVyImPJMz3l39fd3YkMtUQOWqMR339XImStmjgP/byNRFhQIosjdd1eXk1I5Bh1wmL2pnK5pBUD8bwyL/Omr8/POSsn8nZSIVB+dtXS3S/t7juZLbOEmX/e80wqcyuVvZTKTwpOtly97t/mUsV/Dmw0/KfsRiPeu9rJrZT8DCPv8TEf7Vy3WVZxrT+wmP0pBP/+6+qOnzdeTZJWrFjh1lPnu3ffpO7XdnpEO+fMfOq5anfc7dxfyeeqxHWn8sQ86XxJL5duaZ+LFvxc6WUEzmPzaUkvCCFcIulSSS8zs2dK+l1JXw4hXCDpy8X/AWC50JsA5Ir+BGBBkpOz0DRW/Ler+AqSXiXpQ8XPPyTp1UsxQACYC70JQK7oTwAWal6fRTCzspndLumApBtDCDdL2hBC2CtJxb9nRLZ9k5ndYma3NDL8aBSAk9di9aaxY0eXbcwATg+L1p9Gjy3bmAF03rwmZyGEegjhUkmbJF1pZhfN9wpCCNeFEK4IIVxRKp2cn/EFkKfF6k0rVq5asjECOD0tWn8aXLlkYwSQnxP6K94QwhFJ/ybpZZL2m9lGSSr+PbDYgwOA+aA3AcgV/QnAiUhOzsxsvZkNFd/3SXqRpPsk3SDpDcXF3iDpc0s0RgB4HHoTgFzRnwAs1HzWoN0o6UNmVlZzMveJEMI/mdm3JH3CzN4oaaek16V3Ze4yntMzM/FNq05N7S+r6i1pWXWWRpYkq/pLr3d3xZeNb6SWbXer6SXOZ2rVaK2UiC7oTSwL7y3BWyn7+w7mxxOUSv6p6d2fla72lnW2xJL13rk2kzpPE/d33bvuxMmQOpdqbS0X25nl3BMWrTdZydTrxDsEZ4nyuhNXIUnVaqI3+UNT3bnfqtX441tqc4lyf1jJZZOT193GvtPLZHu1xJLMTkTIfK677jwO06tgL3zfkn/MS20ug+1JHZO2l/H3tnW37KjF609KxQksfHn0pVxyvp1l+CU/xih1TqWuO1VvR87L9HtjS/WXds+Vdo55O9fd7rmS2n4pYmGSk7MQwp2SLpvj5wclvXDRRwQA80BvApAr+hOAhVq6Xx0AAAAAAOaNyRkAAAAAZIDJGQAAAABkgMkZAAAAAGSAyRkAAAAAZIDJGQAAAABkwJYzo8jMhiXtaPnROkkjyzaA+ct1XFK+Y8t1XFK+Y8t1XNKJjW1rCGH9Ug5mqZ1EvUnKd2y5jkvKd2y5jkvKd2wnOi760/LJdVxSvmNjXCcu17EtWm9a1snZ467c7JYQwhUdG0BEruOS8h1bruOS8h1bruOS8h7bcsj59uc6tlzHJeU7tlzHJeU7tlzHtZxyPQa5jkvKd2yM68TlOrbFHBcfawQAAACADDA5AwAAAIAMdHpydl2Hrz8m13FJ+Y4t13FJ+Y4t13FJeY9tOeR8+3MdW67jkvIdW67jkvIdW67jWk65HoNcxyXlOzbGdeJyHduijaujf3MGAAAAAGjq9DtnAAAAAAAxOQMAAACALHRkcmZmLzOz+81sm5n9bifGEGNm283sLjO73cxu6eA4PmBmB8zs7pafrTGzG83sweLf1RmN7Voz21Mct9vN7OUdGNdmM7vJzO41s3vM7K3Fzzt63Jxx5XDMes3sO2Z2RzG2Pyx+nsW51gm59qdcelMxliz7E71pUcfW0eNGb3q8XHuTlE9/yrU3OWOjP534uHI4Zkvan5b9b87MrCzpAUkvlrRb0nclvT6E8P1lHUiEmW2XdEUIoaMBd2Z2taQxSR8OIVxU/Oy/SzoUQnhX0ZhXhxDensnYrpU0FkL40+UeT8u4NkraGEK4zcwGJd0q6dWSrlEHj5szrp9S54+ZSRoIIYyZWZekr0t6q6TXKoNzbbnl3J9y6U3FWLLsT/SmRR1bR/sTvemxcu5NUj79Kdfe5IztWtGfTnRcp/xrp068c3alpG0hhIdDCDOSPibpVR0YR9ZCCF+VdGjWj18l6UPF9x9S8yRddpGxdVwIYW8I4bbi+1FJ90o6Wx0+bs64Oi40jRX/7Sq+gjI51zqA/jQPufYnetOijq2j6E2PQ2+ah1x7k0R/WsRxddxS96dOTM7OlrSr5f+7lcnBLgRJXzSzW83sTZ0ezCwbQgh7peZJK+mMDo9ntl83szuLt+47+lETMztH0mWSblZGx23WuKQMjpmZlc3sdkkHJN0YQsjqmC2znPtTzr1Jyvuc6fjj7Lhce5OUX3+iNz1Gzr1Jyrs/5X7O0J9ObFxSBsdsKftTJyZnNsfPclrP/6oQwuWSfkzSW4q3oZH2XknnS7pU0l5Jf9apgZjZCkmfkvS2EMKxTo1jtjnGlcUxCyHUQwiXStok6Uozu6gT48hEzv2J3rQwWTzOpHx7k5Rnf6I3PUbOvUmiPy1Uxx9nx+Xan3LsTdLS9qdOTM52S9rc8v9Nkh7twDjmFEJ4tPj3gKTPqPlRglzsLz6De/yzuAc6PJ4fCCHsL07UhqT3qUPHrfjs76ckfSSE8Onixx0/bnONK5djdlwI4Yikf5P0MmVwzDok2/6UeW+SMj1ncnmc5dqbYmPL5bgVYzkielO2vUnKvj9le87k8jjLtT/l3puK8RzRIvenTkzOvivpAjM718y6Jf20pBs6MI7HMbOB4o8OZWYDkl4i6W5/q2V1g6Q3FN+/QdLnOjiWxzh+MhZeow4ct+IPNN8v6d4QwntaSh09brFxZXLM1pvZUPF9n6QXSbpPGZ9rSyzL/nQS9CYp03Mmk8dZlr3JG1unjxu96XGy7E3SSdGfsj1nOv04K8aQZX/KtTcVY1ja/hRCWPYvSS9Xc9WhhyT9p06MITKu8yTdUXzd08mxSfpHNd+urar5G7M3Slor6cuSHiz+XZPR2P5e0l2S7ixOzo0dGNdz1PyYx52Sbi++Xt7p4+aMK4djdrGk7xVjuFvSO4ufZ3GudeIrx/6UU28qxpNlf6I3LerYOnrc6E1zHpPselMxrmz6U669yRkb/enEx5XDMVvS/rTsS+kDAAAAAB6vIyHUAAAAAIDHYnIGAAAAABlgcgYAAAAAGWByBgAAAAAZYHIGAAAAABlgcgYAAAAAGWByBgAAAAAZ+H9I+iKkp8rfoAAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 1080x432 with 3 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x432 with 3 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import torch\n",
    "import torch.nn as nn\n",
    "from torch.optim import Optimizer\n",
    "from torch.utils.data import DataLoader\n",
    "from torchvision import datasets\n",
    "from torchvision.transforms import transforms\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "from numpy import linspace\n",
    "\n",
    "\n",
    "'''\n",
    "Step 1: (same step)\n",
    "'''\n",
    "classes = ('plane', 'car', 'bird', 'cat','deer', 'dog', 'frog', 'horse', 'ship', 'truck')\n",
    "label_1 = classes.index('plane')\n",
    "label_2 = classes.index('car')\n",
    "\n",
    "train_set = datasets.CIFAR10(root='./cifar_data/', train=True, transform=transforms.ToTensor(), download=True)\n",
    "\n",
    "# Use data with two labels\n",
    "train_set.targets = torch.tensor(train_set.targets)\n",
    "idx = (train_set.targets == label_1) + (train_set.targets == label_2)\n",
    "train_set.data = train_set.data[idx]\n",
    "train_set.targets = train_set.targets[idx]\n",
    "train_set.targets[train_set.targets == label_1] = -1\n",
    "train_set.targets[train_set.targets == label_2] = 1\n",
    "\n",
    "\n",
    "test_set = datasets.CIFAR10(root='./cifar_data/', train=False, transform=transforms.ToTensor(), )\n",
    "\n",
    "# Use data with two labels\n",
    "test_set.targets = torch.tensor(test_set.targets)\n",
    "idx = (test_set.targets == label_1) + (test_set.targets == label_2)\n",
    "test_set.data = test_set.data[idx]\n",
    "test_set.targets = test_set.targets[idx]\n",
    "test_set.targets[test_set.targets == label_1] = -1\n",
    "test_set.targets[test_set.targets == label_2] = 1\n",
    "\n",
    "\n",
    "'''\n",
    "Step 2: Define the neural network class (LOOK HERE)\n",
    "'''\n",
    "class MLP4(nn.Module) :\n",
    "    '''\n",
    "    Initialize model\n",
    "        input_dim : dimension of given input data\n",
    "    '''\n",
    "    # CIFAR-10 data is 32*32 images with 3 RGB channels\n",
    "    def __init__(self, input_dim=3*32*32) :\n",
    "        super().__init__()\n",
    "        self.linear = nn.Linear(input_dim, input_dim//2, bias=True)\n",
    "        self.linear2 = nn.Linear(input_dim//2, input_dim//4, bias=True)\n",
    "        self.linear3 = nn.Linear(input_dim//4, input_dim//8, bias=True)\n",
    "        self.linear4 = nn.Linear(input_dim//8, 1, bias=True)\n",
    "        \n",
    "    ''' forward given input x '''\n",
    "    def forward(self, x) :\n",
    "        x = x.float().view(-1, 3*32*32)\n",
    "        x = nn.functional.relu(self.linear(x))\n",
    "        x = nn.functional.relu(self.linear2(x))\n",
    "        x = nn.functional.relu(self.linear3(x))\n",
    "        x = self.linear4(x)\n",
    "        return x\n",
    "    \n",
    "    \n",
    "'''\n",
    "Step 3: Create the model, specify loss function and optimizer (LOOK HERE)\n",
    "'''\n",
    "model = MLP4()  # Define Neural Network Models \n",
    "\n",
    "def logistic_loss(output, target):\n",
    "    return torch.mean(-torch.nn.functional.logsigmoid(target.reshape(-1)*output.reshape(-1)))\n",
    "loss_function = logistic_loss                            # Specify loss function\n",
    "\n",
    "optimizer = torch.optim.SGD(model.parameters(), lr=3*1e-2)  # specify SGD with learning rate\n",
    "\n",
    "\n",
    "\n",
    "'''\n",
    "Step 4: (same step)\n",
    "'''\n",
    "# Use DataLoader class\n",
    "train_loader = DataLoader(dataset=train_set, batch_size=1024, shuffle=True)\n",
    "import time\n",
    "start = time.time()\n",
    "# Train the model\n",
    "for epoch in range(100) :\n",
    "    for images, labels in train_loader :\n",
    "\n",
    "        # Clear previously computed gradient\n",
    "        optimizer.zero_grad()\n",
    "        # then compute gradient with forward and backward passes\n",
    "        train_loss = loss_function(model(images), labels.float())\n",
    "        train_loss.backward()\n",
    "\n",
    "        # perform SGD step (parameter update)\n",
    "        optimizer.step()\n",
    "end = time.time()\n",
    "print(f\"Time ellapsed in training is: {end - start}\")\n",
    "    \n",
    "\n",
    "\n",
    "'''\n",
    "Step 5: (same step)\n",
    "'''\n",
    "test_loss, correct = 0, 0\n",
    "misclassified_ind = []\n",
    "correct_ind = []\n",
    "\n",
    "# Test data\n",
    "test_loader = DataLoader(dataset=test_set, batch_size=1, shuffle=False)\n",
    "\n",
    "# Evaluate accuracy using test data\n",
    "for ind, (image, label) in enumerate(test_loader) :\n",
    "\n",
    "    # Forward pass\n",
    "    output = model(image)\n",
    "    \n",
    "    # Calculate cumulative loss\n",
    "    test_loss += loss_function(output, label.float()).item()\n",
    "\n",
    "    # Make a prediction\n",
    "    if output.item() * label.item() >= 0 :\n",
    "        correct += 1\n",
    "        correct_ind += [ind]\n",
    "    else:\n",
    "        misclassified_ind += [ind]\n",
    "\n",
    "# Print out the results\n",
    "print('[Test set] Average loss: {:.4f}, Accuracy: {}/{} ({:.2f}%)\\n'.format(\n",
    "        test_loss /len(test_loader), correct, len(test_loader),\n",
    "        100. * correct / len(test_loader)))\n",
    "\n",
    "\n",
    "\n",
    "'''\n",
    "Step 6: (same step)\n",
    "''' \n",
    "# Misclassified images\n",
    "shuffle(misclassified_ind)\n",
    "fig = plt.figure(1, figsize=(15, 6))\n",
    "fig.suptitle('Misclassified Figures', fontsize=16)\n",
    "\n",
    "for k in range(3) :\n",
    "    image = test_set.data[misclassified_ind[k]].astype('uint8')\n",
    "    ax = fig.add_subplot(1, 3, k+1)\n",
    "    true_label = test_set.targets[misclassified_ind[k]]\n",
    "    \n",
    "    if true_label == -1 :\n",
    "        ax.set_title('True Label: {}\\nPrediction: {}'.format(classes[label_1], classes[label_2]))\n",
    "    else :\n",
    "        ax.set_title('True Label: {}\\nPrediction: {}'.format(classes[label_2], classes[label_1]))\n",
    "    plt.imshow(image)\n",
    "plt.show()\n",
    "\n",
    "# Correctly classified images\n",
    "shuffle(correct_ind)\n",
    "fig = plt.figure(2, figsize=(15, 6))\n",
    "fig.suptitle('Correctly-classified Figures', fontsize=16)\n",
    "\n",
    "for k in range(3) :\n",
    "    image = test_set.data[correct_ind[k]].astype('uint8')\n",
    "    ax = fig.add_subplot(1, 3, k+1)\n",
    "    true_label = test_set.targets[correct_ind[k]]\n",
    "\n",
    "    if true_label == -1 :\n",
    "        ax.set_title('True Label: {}\\nPrediction: {}'.format(classes[label_1], classes[label_1]))\n",
    "    else :\n",
    "        ax.set_title('True Label: {}\\nPrediction: {}'.format(classes[label_2], classes[label_2]))\n",
    "    plt.imshow(image)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "MLP model parameters\n",
      "torch.Size([1536, 3072])\n",
      "torch.Size([1536])\n",
      "torch.Size([768, 1536])\n",
      "torch.Size([768])\n",
      "torch.Size([384, 768])\n",
      "torch.Size([384])\n",
      "torch.Size([1, 384])\n",
      "torch.Size([1])\n",
      "MLP has a total of 6196225 parameters.\n"
     ]
    }
   ],
   "source": [
    "print(\"MLP model parameters\")\n",
    "param_num = 0\n",
    "for parameter in model.parameters():\n",
    "    print(parameter.shape)\n",
    "    param_num += parameter.numel()\n",
    "print(f\"MLP has a total of {param_num} parameters.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Softmax regression for MNIST"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Using downloaded and verified file: ./mnist_data/MNIST/raw/train-images-idx3-ubyte.gz\n",
      "Extracting ./mnist_data/MNIST/raw/train-images-idx3-ubyte.gz to ./mnist_data/MNIST/raw\n",
      "Using downloaded and verified file: ./mnist_data/MNIST/raw/train-labels-idx1-ubyte.gz\n",
      "Extracting ./mnist_data/MNIST/raw/train-labels-idx1-ubyte.gz to ./mnist_data/MNIST/raw\n",
      "Using downloaded and verified file: ./mnist_data/MNIST/raw/t10k-images-idx3-ubyte.gz\n",
      "Extracting ./mnist_data/MNIST/raw/t10k-images-idx3-ubyte.gz to ./mnist_data/MNIST/raw\n",
      "Using downloaded and verified file: ./mnist_data/MNIST/raw/t10k-labels-idx1-ubyte.gz\n",
      "Extracting ./mnist_data/MNIST/raw/t10k-labels-idx1-ubyte.gz to ./mnist_data/MNIST/raw\n",
      "Processing...\n",
      "Done!\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/ernestryu/opt/anaconda3/lib/python3.8/site-packages/torchvision/datasets/mnist.py:480: UserWarning: The given NumPy array is not writeable, and PyTorch does not support non-writeable tensors. This means you can write to the underlying (supposedly non-writeable) NumPy array using the tensor. You may want to copy the array to protect its data or make it writeable before converting it to a tensor. This type of warning will be suppressed for the rest of this program. (Triggered internally at  /Users/distiller/project/conda/conda-bld/pytorch_1603740477510/work/torch/csrc/utils/tensor_numpy.cpp:141.)\n",
      "  return torch.from_numpy(parsed.astype(m[2], copy=False)).view(*s)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Time ellapsed in training is: 20.37763786315918\n",
      "[Test set] Average loss: 0.8003, Accuracy: 8471/10000 (84.71%)\n",
      "\n"
     ]
    }
   ],
   "source": [
    "import torch\n",
    "import torch.nn as nn\n",
    "from torch.optim import Optimizer\n",
    "from torch.utils.data import DataLoader\n",
    "from torchvision import datasets\n",
    "from torchvision.transforms import transforms\n",
    "import matplotlib.pyplot as plt\n",
    "'''\n",
    "Step 1: Load the entire MNIST dataset (LOOK HERE)\n",
    "'''\n",
    "\n",
    "train_set = datasets.MNIST(root='./mnist_data/',\n",
    "                               train=True, \n",
    "                               transform=transforms.ToTensor(),\n",
    "                               download=True)\n",
    "\n",
    "test_set = datasets.MNIST(root='./mnist_data/',\n",
    "                              train=False,\n",
    "                              transform=transforms.ToTensor())\n",
    "\n",
    "\n",
    "'''\n",
    "Step 2: Since there are 10 classes, the output should be 10 (LOOK HERE)\n",
    "'''\n",
    "class softmax(nn.Module) :\n",
    "    def __init__(self, input_dim=28*28) :\n",
    "        super().__init__()\n",
    "        self.linear = nn.Linear(input_dim, 10, bias=True)\n",
    "\n",
    "    def forward(self, x) :\n",
    "        return self.linear(x.float().view(-1, 28*28))\n",
    "\n",
    "'''\n",
    "Step 3: Create the model, specify loss function and optimizer (LOOK HERE)\n",
    "'''\n",
    "model = softmax()\n",
    "loss_function = torch.nn.CrossEntropyLoss()\n",
    "optimizer = torch.optim.SGD(model.parameters(), lr=1e-3)\n",
    "\n",
    "\n",
    "'''\n",
    "Step 4: (same step)\n",
    "'''\n",
    "train_loader = DataLoader(dataset=train_set, batch_size=64, shuffle=True)\n",
    "\n",
    "import time\n",
    "start = time.time()\n",
    "for epoch in range(5) :\n",
    "    for images, labels in train_loader :\n",
    "        optimizer.zero_grad()\n",
    "        train_loss = loss_function(model(images), labels)\n",
    "        train_loss.backward()\n",
    "        optimizer.step()\n",
    "end = time.time()\n",
    "print(f\"Time ellapsed in training is: {end - start}\")\n",
    "\n",
    "\n",
    "'''\n",
    "Step 5: Test model (Evaluate the accuracy)\n",
    "'''\n",
    "test_loss, correct = 0, 0\n",
    "\n",
    "test_loader = DataLoader(dataset=test_set, batch_size=1, shuffle=False)\n",
    "\n",
    "for ind, (image, label) in enumerate(test_loader) :\n",
    "    output = model(image)\n",
    "    test_loss += loss_function(output, label).item()\n",
    "    pred = output.max(1, keepdim=True)[1]\n",
    "    correct += pred.eq(label.view_as(pred)).sum().item()\n",
    "\n",
    "            \n",
    "print('[Test set] Average loss: {:.4f}, Accuracy: {}/{} ({:.2f}%)\\n'.format(\n",
    "        test_loss /len(test_loader), correct, len(test_loader),\n",
    "        100. * correct / len(test_loader)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# GPU computing on PyTorch\n",
    "\n",
    "Check availability of GPU on system"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "0\n",
      "1.7.0\n"
     ]
    }
   ],
   "source": [
    "import torch\n",
    "\n",
    "print(torch.cuda.is_available())\n",
    "print(torch.cuda.device_count())\n",
    "\n",
    "print(torch.__version__)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Use `.to(device)` to create a copy of a tensor on the GPU"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cpu\n",
      "cpu\n"
     ]
    }
   ],
   "source": [
    "t = torch.tensor([\n",
    "    [1,1,1,1],\n",
    "    [2,2,2,2],\n",
    "    [3,3,3,3]\n",
    "], dtype=torch.float32)\n",
    "\n",
    "device = \"cpu\"\n",
    "# device = \"cuda:0\"\n",
    "#device = \"cuda:5\" #error if you have fewer than 6 GPUs\n",
    "\n",
    "t_dev = t.to(device)\n",
    "\n",
    "print(t.device)\n",
    "print(t_dev.device)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Perform power iteration"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Time ellapsed in loop is: 1.3693819046020508\n",
      "86.06098\n"
     ]
    }
   ],
   "source": [
    "import torch\n",
    "import numpy as np\n",
    "N = 8192\n",
    "A = torch.normal(0,1/np.sqrt(N),(N,N))    #8*8192^2=512Mb data\n",
    "x = torch.normal(0.0, 1.0,(N,1))\n",
    "\n",
    "\n",
    "device = \"cpu\"\n",
    "# device = \"cuda:0\"\n",
    "A = A.to(device)\n",
    "x = x.to(device)    #error if A is sent to GPU but x is not sent to GPU\n",
    "\n",
    "import time\n",
    "start = time.time()\n",
    "for _ in range(100):\n",
    "    x = A@x  # matrix-vector product\n",
    "end = time.time()\n",
    "print(f\"Time ellapsed in loop is: {end - start}\")\n",
    "\n",
    "x = x.to(\"cpu\")\n",
    "print(np.linalg.norm(x))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Calssification via MLP on GPU\n",
    "\n",
    "(GPU does not provide a speedup as the model is small.)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "import torch.nn as nn\n",
    "from torch.optim import Optimizer\n",
    "from torch.utils.data import DataLoader\n",
    "from torchvision import datasets\n",
    "from torchvision.transforms import transforms\n",
    "\n",
    "device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")\n",
    "\n",
    "'''\n",
    "Step 1\n",
    "'''\n",
    "train_dataset = datasets.MNIST(root='./mnist_data/',\n",
    "                               train=True, \n",
    "                               transform=transforms.ToTensor(),\n",
    "                               download=True)\n",
    "\n",
    "test_dataset = datasets.MNIST(root='./mnist_data/',\n",
    "                              train=False,\n",
    "                              transform=transforms.ToTensor())\n",
    "\n",
    "'''\n",
    "Step 2: Define the neural network class (LOOK HERE)\n",
    "'''\n",
    "class MLP4(nn.Module) :\n",
    "    '''\n",
    "    Initialize model\n",
    "        input_dim : dimension of given input data\n",
    "    '''\n",
    "    def __init__(self, input_dim=28*28) :\n",
    "        super().__init__()\n",
    "        self.linear = nn.Linear(input_dim, input_dim//2, bias=True)\n",
    "        self.linear2 = nn.Linear(input_dim//2, input_dim//4, bias=True)\n",
    "        self.linear3 = nn.Linear(input_dim//4, input_dim//8, bias=True)\n",
    "        self.linear4 = nn.Linear(input_dim//8, 10, bias=True)\n",
    "        \n",
    "    ''' forward given input x '''\n",
    "    def forward(self, x) :\n",
    "        x = x.float().view(-1, 28*28)\n",
    "        x = nn.functional.relu(self.linear(x))\n",
    "        x = nn.functional.relu(self.linear2(x))\n",
    "        x = nn.functional.relu(self.linear3(x))\n",
    "        x = self.linear4(x)\n",
    "        return x\n",
    "'''\n",
    "Step 3 Instantiate model and send it to device (LOOK HERE)\n",
    "'''\n",
    "model = MLP4().to(device)\n",
    "loss_function = torch.nn.CrossEntropyLoss()\n",
    "optimizer = torch.optim.SGD(model.parameters(), lr=1e-1)\n",
    "\n",
    "\n",
    "'''\n",
    "Step 4 Load batch, send it to device, and perform SGD (LOOK HERE)\n",
    "'''\n",
    "train_loader = torch.utils.data.DataLoader(dataset=train_dataset, batch_size=1024, shuffle=True)\n",
    "\n",
    "import time\n",
    "start = time.time()\n",
    "for epoch in range(1) :\n",
    "    for images, labels in train_loader :\n",
    "        images, labels = images.to(device), labels.to(device)\n",
    "        \n",
    "        optimizer.zero_grad()\n",
    "        train_loss = loss_function(model(images), labels)\n",
    "        train_loss.backward()\n",
    "\n",
    "        optimizer.step()\n",
    "end = time.time()\n",
    "print(\"Time ellapsed in training is: {}\".format(end - start))\n",
    "\n",
    "\n",
    "\n",
    "'''\n",
    "Step 5 Load batch, send it to device, and peform test (LOOK HERE)\n",
    "'''\n",
    "test_loss, correct, total = 0, 0, 0\n",
    "\n",
    "test_loader = torch.utils.data.DataLoader(dataset=test_dataset, batch_size=1024, shuffle=False)\n",
    "\n",
    "for images, labels in test_loader :\n",
    "    images, labels = images.to(device), labels.to(device)\n",
    "\n",
    "    output = model(images)\n",
    "    test_loss += loss_function(output, labels).item()\n",
    "\n",
    "    pred = output.max(1, keepdim=True)[1]\n",
    "    correct += pred.eq(labels.view_as(pred)).sum().item()\n",
    "    \n",
    "    total += labels.size(0)\n",
    "            \n",
    "print('[Test set] Average loss: {:.4f}, Accuracy: {}/{} ({:.2f}%)\\n'.format(\n",
    "        test_loss /total, correct, total,\n",
    "        100. * correct / total))\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}